1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 package de.bea.domingo;
24
25 import java.util.Calendar;
26 import java.util.Iterator;
27 import java.util.List;
28
29 /***
30 * Represents a view or folder of a database and provides access to documents
31 * within it.
32 *
33 * @author <a href=mailto:kriede@users.sourceforge.net>Kurt Riede</a>
34 */
35 public interface DView extends DBase {
36
37 /***
38 * Updates view contents with any changes that have occurred to the
39 * database since the View object was created, or since the last refresh.
40 */
41 void refresh();
42
43 /***
44 * Returns the name of a view.
45 *
46 * @return view name
47 */
48 String getName();
49
50 /***
51 * Finds a document based on the first column value within a view.
52 * Returns <code>null</code> if there are no matching document.
53 *
54 * @param key - String
55 * A partial key must not be in a categorized colum!
56 * @param exact - boolean
57 *
58 * @return DDocument
59 */
60 DDocument getDocumentByKey(String key, boolean exact);
61
62 /***
63 * Finds a document based on its column values within a view.
64 * Returns <code>null</code> if there are no matching document.
65 *
66 * @param keys - List(Column-Value)
67 * A partial key must not be in a categorized colum!
68 * @param exact - boolean
69 *
70 * @return DDocument
71 */
72 DDocument getDocumentByKey(List keys, boolean exact);
73
74 /***
75 * Finds documents based on their column values within a view.
76 * Returns all documents in the view whose column values partially match
77 * one of the keys. If no documents match, the collection is empty and the
78 * count is zero.
79 *
80 * <p><b>Note</b>
81 * The use of partial matches with multiple keys may result in missed
82 * entries. If the first key is partial and the second column does not
83 * sort the same with the partial key as with the exact key, entries that
84 * fall out of sequence are missed.
85 * A partial key must not be in a categorized colum!</p>
86 *
87 * @param key key
88 *
89 * @return Iterator
90 */
91 Iterator getAllDocumentsByKey(String key);
92
93 /***
94 * Finds documents based on their column values within a view.
95 * Returns all documents in the view whose column values partially match
96 * one of the keys. If no documents match, the collection is empty and the
97 * count is zero.
98 *
99 * <p><b>Note</b>
100 * The use of partial matches with multiple keys may result in missed
101 * entries. If the first key is partial and the second column does not
102 * sort the same with the partial key as with the exact key, entries that
103 * fall out of sequence are missed.
104 * A partial key must not be in a categorized colum!</p>
105 *
106 * @param key key
107 *
108 * @return Iterator
109 */
110 Iterator getAllDocumentsByKey(Calendar key);
111
112 /***
113 * Finds documents based on their column values within a view.
114 * Returns all documents in the view whose column values partially match
115 * one of the keys. If no documents match, the collection is empty and the
116 * count is zero.
117 *
118 * <p><b>Note</b>
119 * The use of partial matches with multiple keys may result in missed
120 * entries. If the first key is partial and the second column does not
121 * sort the same with the partial key as with the exact key, entries that
122 * fall out of sequence are missed.
123 * A partial key must not be in a categorized colum!</p>
124 *
125 * @param key key
126 *
127 * @return Iterator
128 */
129 Iterator getAllDocumentsByKey(double key);
130
131 /***
132 * Finds documents based on their column values within a view.
133 * Returns all documents in the view whose column values partially match
134 * one of the keys. If no documents match, the collection is empty and the
135 * count is zero.
136 *
137 * <p><b>Note</b>
138 * The use of partial matches with multiple keys may result in missed
139 * entries. If the first key is partial and the second column does not
140 * sort the same with the partial key as with the exact key, entries that
141 * fall out of sequence are missed.
142 * A partial key must not be in a categorized colum!</p>
143 *
144 * @param key key
145 *
146 * @return Iterator
147 */
148 Iterator getAllDocumentsByKey(int key);
149
150 /***
151 * Finds documents based on their column values within a view.
152 * Returns all documents in the view whose column values partially match
153 * one of the keys. If no documents match, the collection is empty and the
154 * count is zero.
155 *
156 * <p><b>Note</b>
157 * The use of partial matches with multiple keys may result in missed
158 * entries. If the first key is partial and the second column does not
159 * sort the same with the partial key as with the exact key, entries that
160 * fall out of sequence are missed.
161 * A partial key must not be in a categorized colum!</p>
162 *
163 * @param keys list of keys
164 *
165 * @return Iterator
166 */
167 Iterator getAllDocumentsByKey(List keys);
168
169 /***
170 * Finds documents based on their column values within a view.
171 * Returns all documents in the view whose column values match
172 * each of the keys. If no documents match, the collection is empty and the
173 * count is zero.
174 *
175 * <p><b>Note</b>
176 * The use of partial matches with multiple keys may result in missed
177 * entries. If the first key is partial and the second column does not
178 * sort the same with the partial key as with the exact key, entries that
179 * fall out of sequence are missed.
180 * A partial key must not be in a categorized colum!</p>
181 *
182 * @param key key
183 * @param exact True if you want to find an exact match. If you specify
184 * false or omit this parameter, a partial match succeeds.
185 * The use of partial matches with multiple keys may result in
186 * missed documents. If the first key is partial and the second
187 * column does not sort the same with the partial key as with the
188 * exact key, documents that fall out of sequence are missed.
189 * A partial key must not be in a categorized colum!
190 * @return Iterator all documents in the view whose column values match
191 * the keys. If no documents match, the collection is empty
192 * and the count is zero.
193 */
194 Iterator getAllDocumentsByKey(String key, boolean exact);
195
196 /***
197 * Finds documents based on their column values within a view.
198 * Returns all documents in the view whose column values match
199 * each of the keys. If no documents match, the collection is empty and the
200 * count is zero.
201 *
202 * <p><b>Note</b>
203 * The use of partial matches with multiple keys may result in missed
204 * entries. If the first key is partial and the second column does not
205 * sort the same with the partial key as with the exact key, entries that
206 * fall out of sequence are missed.
207 * A partial key must not be in a categorized colum!</p>
208 *
209 * @param key key
210 * @param exact True if you want to find an exact match. If you specify
211 * false or omit this parameter, a partial match succeeds.
212 * The use of partial matches with multiple keys may result in
213 * missed documents. If the first key is partial and the second
214 * column does not sort the same with the partial key as with the
215 * exact key, documents that fall out of sequence are missed.
216 * A partial key must not be in a categorized colum!
217 * @return Iterator all documents in the view whose column values match
218 * the keys. If no documents match, the collection is empty
219 * and the count is zero.
220 */
221 Iterator getAllDocumentsByKey(Calendar key, boolean exact);
222
223 /***
224 * Finds documents based on their column values within a view.
225 * Returns all documents in the view whose column values match
226 * each of the keys. If no documents match, the collection is empty and the
227 * count is zero.
228 *
229 * <p><b>Note</b>
230 * The use of partial matches with multiple keys may result in missed
231 * entries. If the first key is partial and the second column does not
232 * sort the same with the partial key as with the exact key, entries that
233 * fall out of sequence are missed.
234 * A partial key must not be in a categorized colum!</p>
235 *
236 * @param key key
237 * @param exact True if you want to find an exact match. If you specify
238 * false or omit this parameter, a partial match succeeds.
239 * The use of partial matches with multiple keys may result in
240 * missed documents. If the first key is partial and the second
241 * column does not sort the same with the partial key as with the
242 * exact key, documents that fall out of sequence are missed.
243 * A partial key must not be in a categorized colum!
244 * @return Iterator all documents in the view whose column values match
245 * the keys. If no documents match, the collection is empty
246 * and the count is zero.
247 */
248 Iterator getAllDocumentsByKey(double key, boolean exact);
249
250 /***
251 * Finds documents based on their column values within a view.
252 * Returns all documents in the view whose column values match
253 * each of the keys. If no documents match, the collection is empty and the
254 * count is zero.
255 *
256 * <p><b>Note</b>
257 * The use of partial matches with multiple keys may result in missed
258 * entries. If the first key is partial and the second column does not
259 * sort the same with the partial key as with the exact key, entries that
260 * fall out of sequence are missed.
261 * A partial key must not be in a categorized colum!</p>
262 *
263 * @param key key
264 * @param exact True if you want to find an exact match. If you specify
265 * false or omit this parameter, a partial match succeeds.
266 * The use of partial matches with multiple keys may result in
267 * missed documents. If the first key is partial and the second
268 * column does not sort the same with the partial key as with the
269 * exact key, documents that fall out of sequence are missed.
270 * A partial key must not be in a categorized colum!
271 * @return Iterator all documents in the view whose column values match
272 * the keys. If no documents match, the collection is empty
273 * and the count is zero.
274 */
275 Iterator getAllDocumentsByKey(int key, boolean exact);
276
277 /***
278 * Finds documents based on their column values within a view.
279 * Returns all documents in the view whose column values match
280 * each of the keys. If no documents match, the collection is empty and the
281 * count is zero.
282 *
283 * <p><b>Note</b>
284 * The use of partial matches with multiple keys may result in missed
285 * entries. If the first key is partial and the second column does not
286 * sort the same with the partial key as with the exact key, entries that
287 * fall out of sequence are missed.
288 * A partial key must not be in a categorized colum!</p>
289 *
290 * @param keys list of keys
291 * @param exact True if you want to find an exact match. If you specify
292 * false or omit this parameter, a partial match succeeds.
293 * The use of partial matches with multiple keys may result in
294 * missed documents. If the first key is partial and the second
295 * column does not sort the same with the partial key as with the
296 * exact key, documents that fall out of sequence are missed.
297 * A partial key must not be in a categorized colum!
298 * @return Iterator all documents in the view whose column values match
299 * the keys. If no documents match, the collection is empty
300 * and the count is zero.
301 */
302 Iterator getAllDocumentsByKey(List keys, boolean exact);
303
304 /***
305 * Returns an Iterator to loop over all documents in the view.
306 *
307 * @return Iterator
308 */
309 Iterator getAllDocuments();
310
311 /***
312 * Iterator over all entries in a view in view order.
313 *
314 * <p>A view entry collection contains only document entries (no categories
315 * or totals). If a view is filtered by FTSearch, this property returns the
316 * entries in the filtered view.</p>
317 *
318 * @return Iterator over all entries in a view in view order.
319 * @see de.bea.domingo.DViewEntry
320 */
321 Iterator getAllEntries();
322
323 /***
324 * Iterator over all entries in a view in reverse view order.
325 *
326 * <p>A view entry collection contains only document entries (no categories
327 * or totals). If a view is filtered by FTSearch, this property returns the
328 * entries in the filtered view.</p>
329 *
330 * @return Iterator over all entries in a view in view order.
331 * @see de.bea.domingo.DViewEntry
332 */
333 Iterator getAllEntriesReverse();
334
335 /***
336 * Finds a view entry based on its column values within a view.
337 *
338 * <p>You create a key or vector of keys, where each key corresponds to a
339 * value in a sorted column in the view. The method returns the first
340 * entry with column values that match the keys.</p>
341 *
342 * <p>This method returns only the first entry with column values that
343 * match the strings you indicate. To locate all matching documents, use
344 * {@link #getAllEntriesByKey(String)}</p>
345 *
346 * @param key String that is compared to the first sorted column in the
347 * view.
348 * @return The first entry in the view with column values that match the
349 * keys. Returns <code>null</code> if there are no matching entries.
350 */
351 DViewEntry getEntryByKey(String key);
352
353 /***
354 * Finds a view entry based on its column values within a view.
355 *
356 * <p>You create a key or vector of keys, where each key corresponds to a
357 * value in a sorted column in the view. The method returns the first
358 * entry with column values that match the keys.</p>
359 *
360 * <p>This method returns only the first entry with column values that
361 * match the strings you indicate. To locate all matching documents, use
362 * {@link #getAllEntriesByKey(String)}</p>
363 *
364 * @param key String that is compared to the first sorted column in the view.
365 * @param exact use true if you want an exact match or false for a partial
366 * one
367 * @return The first entry in the view with column values that match the
368 * keys. Returns <code>null</code> if there are no matching entries.
369 */
370 DViewEntry getEntryByKey(String key, boolean exact);
371
372 /***
373 * Finds a view entry based on its column values within a view.
374 *
375 * <p>You create a key or vector of keys, where each key corresponds to a
376 * value in a sorted column in the view. The method returns the first
377 * entry with column values that match the keys.</p>
378 *
379 * <p>This method returns only the first entry with column values that
380 * match the strings you indicate. To locate all matching documents, use
381 * {@link #getAllEntriesByKey(String)}</p>
382 *
383 * @param keys A String object that is compared to the first sorted column
384 * in the view. The List only must contain the types String, Date,
385 * Double and Integer
386 * @return The first entry in the view with column values that match the
387 * keys. Returns <code>null</code> if there are no matching entries.
388 */
389 DViewEntry getEntryByKey(List keys);
390
391 /***
392 * Finds a view entry based on its column values within a view.
393 *
394 * <p>You create a key or vector of keys, where each key corresponds to a
395 * value in a sorted column in the view. The method returns the first
396 * entry with column values that match the keys.</p>
397 *
398 * <p>This method returns only the first entry with column values that
399 * match the strings you indicate. To locate all matching documents, use
400 * {@link #getAllEntriesByKey(String)}</p>
401 *
402 * @param keys A String object that is compared to the first sorted column
403 * in the view. The List only must contain the types String, Date,
404 * Double and Integer
405 * @param exact use true if you want an exact match or false for a partial
406 * one
407 * @return The first entry in the view with column values that match the keys.
408 * Returns <code>null</code> if there are no matching entries.
409 */
410 DViewEntry getEntryByKey(List keys, boolean exact);
411
412 /***
413 * Iterator over all entries in a view in view order starting with a given
414 * entry.
415 *
416 * <p>A view entry collection contains only document entries (no categories
417 * or totals). If a view is filtered by FTSearch, this property returns the
418 * entries in the filtered view.</p>
419 *
420 * @param entry A Document or ViewEntry object. Cannot be null.
421 * @return Iterator over all entries in a view in view order starting with
422 * a given entry.
423 * @see de.bea.domingo.DViewEntry
424 */
425 Iterator getAllEntries(DViewEntry entry);
426
427 /***
428 * Finds view entries of type document based on their column values within
429 * a view. You create a key or vector of keys, where each key corresponds
430 * to a value in a sorted column in the view. The method returns all
431 * entries whose column values match the keys.
432 *
433 * Matches are not case-sensitive.
434 *
435 * <p><b>Note</b>
436 * For the getAllEntriesByKey method to work using a key, you must have at
437 * least one column sorted for every key in the array.</p>
438 *
439 * <p><b>Note</b>
440 * The use of partial matches with multiple keys may result in missed
441 * entries. If the first key is partial and the second column does not
442 * sort the same with the partial key as with the exact key, entries that
443 * fall out of sequence are missed.</p>
444 *
445 * @param key A String object that is compared to the first sorted column
446 * in the view.
447 * @return a iterator providing all matching <code>ViewEntry</code>s,
448 * Entries returned by this method are in view order.
449 * @see de.bea.domingo.DViewEntry
450 */
451 Iterator getAllEntriesByKey(String key);
452
453 /***
454 * Finds view entries of type document based on their column values within
455 * a view. You create a key or vector of keys, where each key corresponds
456 * to a value in a sorted column in the view. The method returns all
457 * entries whose column values match the keys.
458 *
459 * Matches are not case-sensitive.
460 *
461 * <p><b>Note</b>
462 * For the getAllEntriesByKey method to work using a key, you must have at
463 * least one column sorted for every key in the array.</p>
464 *
465 * <p><b>Note</b>
466 * The use of partial matches with multiple keys may result in missed
467 * entries. If the first key is partial and the second column does not
468 * sort the same with the partial key as with the exact key, entries that
469 * fall out of sequence are missed.</p>
470 *
471 * @param key A String object that is compared to the first sorted column
472 * in the view.
473 * @param exact use true if you want an exact match or false for a partial
474 * one
475 * @return a iterator providing all matching <code>ViewEntry</code>s,
476 * Entries returned by this method are in view order.
477 * @see de.bea.domingo.DViewEntry
478 */
479 Iterator getAllEntriesByKey(String key, boolean exact);
480
481 /***
482 * Finds view entries of type document based on their column values within
483 * a view. You create a key or vector of keys, where each key corresponds
484 * to a value in a sorted column in the view. The method returns all
485 * entries whose column values match the keys.
486 *
487 * Matches are not case-sensitive.
488 *
489 * <p><b>Note</b>
490 * For the getAllEntriesByKey method to work using a key, you must have at
491 * least one column sorted for every key in the array.</p>
492 *
493 * <p><b>Note</b>
494 * The use of partial matches with multiple keys may result in missed
495 * entries. If the first key is partial and the second column does not
496 * sort the same with the partial key as with the exact key, entries that
497 * fall out of sequence are missed.</p>
498 *
499 * @param key A String object that is compared to the first sorted column
500 * in the view. The List only must contain the types String, Date,
501 * Double and Integer
502 * @return a iterator providing all matching <code>ViewEntry</code>s,
503 * Entries returned by this method are in view order.
504 * @see de.bea.domingo.DViewEntry
505 */
506 Iterator getAllEntriesByKey(List key);
507
508 /***
509 * Finds view entries of type document based on their column values within
510 * a view. You create a key or vector of keys, where each key corresponds
511 * to a value in a sorted column in the view. The method returns all
512 * entries whose column values match the keys.
513 *
514 * Matches are not case-sensitive.
515 *
516 * <p><b>Note</b>
517 * For the getAllEntriesByKey method to work using a key, you must have at
518 * least one column sorted for every key in the array.</p>
519 *
520 * <p><b>Note</b>
521 * The use of partial matches with multiple keys may result in missed
522 * entries. If the first key is partial and the second column does not
523 * sort the same with the partial key as with the exact key, entries that
524 * fall out of sequence are missed.</p>
525 *
526 * @param key A List object that is compared to the first sorted column
527 * in the view. The List only must contain the types String, Date,
528 * Double and Integer
529 * @param exact use true if you want an exact match or false for a partial
530 * one
531 * @return a iterator providing all matching <code>ViewEntry</code>s,
532 * Entries returned by this method are in view order.
533 * @see de.bea.domingo.DViewEntry
534 */
535 Iterator getAllEntriesByKey(List key, boolean exact);
536
537 /***
538 * Finds view entries of type document based on their column values within
539 * a view. You create a key or vector of keys, where each key corresponds
540 * to a value in a sorted column in the view. The method returns all
541 * entries whose column values match the keys.
542 *
543 * Matches are not case-sensitive.
544 *
545 * <p><b>Note</b>
546 * For the getAllEntriesByKey method to work using a key, you must have at
547 * least one column sorted for every key in the array.</p>
548 *
549 * <p><b>Note</b>
550 * The use of partial matches with multiple keys may result in missed
551 * entries. If the first key is partial and the second column does not
552 * sort the same with the partial key as with the exact key, entries that
553 * fall out of sequence are missed.</p>
554 *
555 * @param start A Calendar object that represents the start of a date range.
556 * Compared to the first column in the view.
557 * @param end A Calendar object that represents the start of a end range.
558 * Compared to the first column in the view.
559 *
560 * @param exact use true if you want an exact match or false for a partial
561 * one
562 * @return a iterator providing all matching <code>ViewEntry</code>s,
563 * Entries returned by this method are in view order.
564 * @see de.bea.domingo.DViewEntry
565 */
566 Iterator getAllEntriesByKey(Calendar start, Calendar end, boolean exact);
567
568 /***
569 * Finds view entries of type category.
570 * This method returns an iterator over all top level categories.
571 * Sub categories are not included. Use {@link #getAllCategories(int)}
572 * to retrieve sub categories.
573 *
574 * @return a iterator providing all matching <code>ViewEntry</code>s,
575 * Entries returned by this method are in view order.
576 * @see de.bea.domingo.DViewEntry
577 */
578 Iterator getAllCategories();
579
580 /***
581 * Finds view entries of type category upto a given level.
582 *
583 * @param level The maximum level of navigation 0 (top level) through 30
584 * (default).
585 * @return a iterator providing all matching <code>ViewEntry</code>s,
586 * Entries returned by this method are in view order.
587 * @see de.bea.domingo.DViewEntry
588 */
589 Iterator getAllCategories(int level);
590
591 /***
592 * Finds view entries of type category where the category partially
593 * matches the given key.
594 *
595 * Matches are not case-sensitive.
596 *
597 * <p><b>Note</b>
598 * For the getAllCategoriesByKey method to work using a key, you must have at
599 * least one column categorized.</p>
600 *
601 * <p><b>Note</b>
602 * The use of partial matches with multiple keys may result in missed
603 * entries. If the first key is partial and the second column does not
604 * sort the same with the partial key as with the exact key, entries that
605 * fall out of sequence are missed.</p>
606 *
607 * @param key A String that is compared to the first categorized column
608 * in the view.
609 * @return a iterator providing all matching <code>ViewEntry</code>s,
610 * Entries returned by this method are in view order.
611 * @see de.bea.domingo.DViewEntry
612 * @deprecated not yet fully implemented and not yet tested
613 */
614 Iterator getAllCategoriesByKey(String key);
615
616 /***
617 * Finds view entries of type category upto a given level where the
618 * categories partially match the given key.
619 *
620 * Matches are not case-sensitive.
621 *
622 * <p><b>Note</b>
623 * For the getAllCategoriesByKey method to work using a key, you must have at
624 * least one column categorized for every key in the array.</p>
625 *
626 * <p><b>Note</b>
627 * The use of partial matches with multiple keys may result in missed
628 * entries. If the first key is partial and the second column does not
629 * sort the same with the partial key as with the exact key, entries that
630 * fall out of sequence are missed.</p>
631 *
632 * @param key A List object that is compared to the first sorted column
633 * in the view. The List only must contain the types String, Date,
634 * Double and Integer
635 * @param level The maximum level of navigation 0 (top level) through 30
636 * (default).
637 * @return a iterator providing all matching <code>ViewEntry</code>s,
638 * Entries returned by this method are in view order.
639 * @see de.bea.domingo.DViewEntry
640 * @deprecated not yet fully implemented and not yet tested
641 */
642 Iterator getAllCategoriesByKey(String key, int level);
643
644 /***
645 * Finds view entries of type category upto a given level where the
646 * categories match the given key.
647 *
648 * Finds view entries of type category upto a given level based on their
649 * column values within a view. You create a key or vector of keys, where
650 * each key corresponds to a value in a sorted column in the view. The
651 * method returns all entries whose column values match the keys.
652 *
653 * Matches are not case-sensitive.
654 *
655 * <p><b>Note</b>
656 * For the getAllCategoriesByKey method to work using a key, you must have at
657 * least one column categorized for every key in the array.</p>
658 *
659 * <p><b>Note</b>
660 * The use of partial matches with multiple keys may result in missed
661 * entries. If the first key is partial and the second column does not
662 * sort the same with the partial key as with the exact key, entries that
663 * fall out of sequence are missed.</p>
664 *
665 * @param key A List object that is compared to the first sorted column
666 * in the view. The List only must contain the types String, Date,
667 * Double and Integer
668 * @param exact use true if you want an exact match or false for a partial
669 * one
670 * @return a iterator providing all matching <code>ViewEntry</code>s,
671 * Entries returned by this method are in view order.
672 * @see de.bea.domingo.DViewEntry
673 * @deprecated not yet fully implemented and not yet tested
674 */
675 Iterator getAllCategoriesByKey(String key, boolean exact);
676
677 /***
678 * Finds view entries of type category upto a given level based on their
679 * column values within a view. You create a key or vector of keys, where
680 * each key corresponds to a value in a sorted column in the view. The
681 * method returns all entries whose column values match the keys.
682 *
683 * Matches are not case-sensitive.
684 *
685 * <p><b>Note</b>
686 * For the getAllCategoriesByKey method to work using a key, you must have at
687 * least one column categorized for every key in the array.</p>
688 *
689 * <p><b>Note</b>
690 * The use of partial matches with multiple keys may result in missed
691 * entries. If the first key is partial and the second column does not
692 * sort the same with the partial key as with the exact key, entries that
693 * fall out of sequence are missed.</p>
694 *
695 * @param key A List object that is compared to the first sorted column
696 * in the view. The List only must contain the types String, Date,
697 * Double and Integer
698 * @param level The maximum level of navigation 0 (top level) through 30
699 * (default).
700 * @param exact use true if you want an exact match or false for a partial
701 * one
702 * @return a iterator providing all matching <code>ViewEntry</code>s,
703 * Entries returned by this method are in view order.
704 * @see de.bea.domingo.DViewEntry
705 * @deprecated not yet fully implemented and not yet tested
706 */
707 Iterator getAllCategoriesByKey(String key, int level, boolean exact);
708
709 /***
710 * Finds view entries of type category upto a given level based on their
711 * column values within a view. You create a key or vector of keys, where
712 * each key corresponds to a value in a sorted column in the view. The
713 * method returns all entries whose column values match the keys.
714 *
715 * Matches are not case-sensitive.
716 *
717 * <p><b>Note</b>
718 * For the getAllCategoriesByKey method to work using a key, you must have at
719 * least one column categorized for every key in the array.</p>
720 *
721 * <p><b>Note</b>
722 * The use of partial matches with multiple keys may result in missed
723 * entries. If the first key is partial and the second column does not
724 * sort the same with the partial key as with the exact key, entries that
725 * fall out of sequence are missed.</p>
726 *
727 * @param key A List object that is compared to the first sorted column
728 * in the view. The List only must contain the types String, Date,
729 * Double and Integer
730 * @return a iterator providing all matching <code>ViewEntry</code>s,
731 * Entries returned by this method are in view order.
732 * @see de.bea.domingo.DViewEntry
733 * @deprecated not yet fully implemented and not yet tested
734 */
735 Iterator getAllCategoriesByKey(List key);
736
737 /***
738 * Finds view entries of type category upto a given level based on their
739 * column values within a view. You create a key or vector of keys, where
740 * each key corresponds to a value in a sorted column in the view. The
741 * method returns all entries whose column values match the keys.
742 *
743 * Matches are not case-sensitive.
744 *
745 * <p><b>Note</b>
746 * For the getAllCategoriesByKey method to work using a key, you must have at
747 * least one column categorized for every key in the array.</p>
748 *
749 * <p><b>Note</b>
750 * The use of partial matches with multiple keys may result in missed
751 * entries. If the first key is partial and the second column does not
752 * sort the same with the partial key as with the exact key, entries that
753 * fall out of sequence are missed.</p>
754 *
755 * @param key A List object that is compared to the first sorted column
756 * in the view. The List only must contain the types String, Date,
757 * Double and Integer
758 * @param level The maximum level of navigation 0 (top level) through 30
759 * (default).
760 * @return a iterator providing all matching <code>ViewEntry</code>s,
761 * Entries returned by this method are in view order.
762 * @see de.bea.domingo.DViewEntry
763 * @deprecated not yet fully implemented and not yet tested
764 */
765 Iterator getAllCategoriesByKey(List key, int level);
766
767 /***
768 * Finds view entries of type category upto a given level based on their
769 * column values within a view. You create a key or vector of keys, where
770 * each key corresponds to a value in a sorted column in the view. The
771 * method returns all entries whose column values match the keys.
772 *
773 * Matches are not case-sensitive.
774 *
775 * <p><b>Note</b>
776 * For the getAllCategoriesByKey method to work using a key, you must have at
777 * least one column categorized for every key in the array.</p>
778 *
779 * <p><b>Note</b>
780 * The use of partial matches with multiple keys may result in missed
781 * entries. If the first key is partial and the second column does not
782 * sort the same with the partial key as with the exact key, entries that
783 * fall out of sequence are missed.</p>
784 *
785 * @param key A List object that is compared to the first sorted column
786 * in the view. The List only must contain the types String, Date,
787 * Double and Integer
788 * @param exact use true if you want an exact match or false for a partial
789 * one
790 * @return a iterator providing all matching <code>ViewEntry</code>s,
791 * Entries returned by this method are in view order.
792 * @see de.bea.domingo.DViewEntry
793 * @deprecated not yet fully implemented and not yet tested
794 */
795 Iterator getAllCategoriesByKey(List key, boolean exact);
796
797 /***
798 * Finds view entries of type category upto a given level based on their
799 * column values within a view. You create a key or vector of keys, where
800 * each key corresponds to a value in a sorted column in the view. The
801 * method returns all entries whose column values match the keys.
802 *
803 * Matches are not case-sensitive.
804 *
805 * <p><b>Note</b>
806 * For the getAllCategoriesByKey method to work using a key, you must have at
807 * least one column categorized for every key in the array.</p>
808 *
809 * <p><b>Note</b>
810 * The use of partial matches with multiple keys may result in missed
811 * entries. If the first key is partial and the second column does not
812 * sort the same with the partial key as with the exact key, entries that
813 * fall out of sequence are missed.</p>
814 *
815 * @param key A List object that is compared to the first sorted column
816 * in the view. The List only must contain the types String, Date,
817 * Double and Integer
818 * @param exact use true if you want an exact match or false for a partial
819 * one
820 * @param level The maximum level of navigation 0 (top level) through 30
821 * (default).
822 * @return a iterator providing all matching <code>ViewEntry</code>s,
823 * Entries returned by this method are in view order.
824 * @see de.bea.domingo.DViewEntry
825 * @deprecated not yet fully implemented and not yet tested
826 */
827 Iterator getAllCategoriesByKey(List key, int level, boolean exact);
828
829 /***
830 * Conducts a full-text search on all documents in a view and filters the
831 * view so it represents only those documents that match the full-text
832 * query. This method does not find word variants.
833 *
834 * <p>See {@link #fullTextSearch(String, int)} for more details.</p>
835 *
836 * @param query The full-text query. See the "Query Syntax" for details
837 * @return The number of documents in the view after the search. Each of these documents matches the query.
838 */
839 int fullTextSearch(String query);
840
841 /***
842 * Conducts a full-text search on all documents in a view and filters the
843 * view so it represents only those documents that match the full-text
844 * query. This method does not find word variants.
845 *
846 * <p><b>Usage</b></p>
847 * <p>After calling FTSearch, you can use the regular View methods to
848 * navigate the result, which is a subset of the documents in the view. If
849 * the database is not full-text indexed, the documents in the subset are in
850 * the same order as they are in the original view. However, if the database
851 * is full-text indexed, the documents in the subset are sorted into
852 * descending order of relevance. The method getFirstDocument returns the
853 * first document in the subset, getLastDocument returns the last document,
854 * and so on.</p>
855 *
856 * <p>Use the {@link #clear} method to clear the full-text search filtering.
857 * The View methods now navigate to the full set of documents in the view.</p>
858 *
859 * <p>If the database is not full-text indexed, this method works,
860 * but less efficiently. To test for an index, use {@link DDatabase#isFTIndexed()}.</p>
861 * <p>To create an index on a local database, use {@link DDatabase#updateFTIndex(boolean)}.</p>
862 *
863 * <p><b>Query syntax</b></p>
864 * <p>To search for a word or phrase, enter the word or phrase as is,
865 * except that search keywords must be enclosed in quotes. Remember to
866 * escape quotes if you are inside a literal. Wildcards, operators, and
867 * other syntax are permitted. For the complete syntax rules, see "Finding
868 * documents in a database" in Lotus Notes 6 Help.</p>
869 *
870 * @param query The full-text query. See the "Query Syntax" for details
871 * @param maxdocs The maximum number of documents you want returned from the
872 * search. If you want to receive all documents that match the
873 * query, specify 0
874 * @return The number of documents in the view after the search. Each of these documents matches the query.
875 */
876 int fullTextSearch(String query, int maxdocs);
877
878 /***
879 * Clears the full-text search filtering on a view. Subsequent calls to
880 * getDocument methods get all documents in the view, not just the search
881 * results.
882 */
883 void clear();
884
885 /***
886 * Sets the selection formula of a view.
887 *
888 * @param formula new selection formula
889 * @since Lotus Notes R6.5
890 */
891 void setSelectionFormula(String formula);
892
893 /***
894 * Returns the selection formula of a view.
895 *
896 * @return selection formula
897 * @since Lotus Notes R6.5
898 */
899 String getSelectionFormula();
900
901 /***
902 * Retutrns the names of the columns in a view.
903 *
904 * The order of the column names in the list corresponds to the order of
905 * the columns in the view, from left to right.
906 *
907 * @return list ofd column names
908 */
909 List getColumnNames();
910
911 /***
912 * Returns the number of columns in a view.
913 *
914 * @return number of columns
915 */
916 int getColumnCount();
917
918 /***
919 * Returns a specified column in a view.
920 *
921 * @param i A column number where 1 is the first column. Cannot be less than 1
922 * or greater than the number of columns in the view.
923 * @return the specified column.
924 */
925 DViewColumn getColumn(int i);
926
927 /***
928 * Returns the columns in a view.
929 *
930 * <p>The order of ViewColumn objects in the vector corresponds to the
931 * order of the columns in the view, from left to right.</p>
932 *
933 * @return list of all columns
934 */
935 List getColumns();
936 }