KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencrx > kernel > depot1 > cci > DepotFilterImpl


1 // ----------------------------------------------------------------------------
2
// Filter/ImplBegin
3
// ----------------------------------------------------------------------------
4
//////////////////////////////////////////////////////////////////////////////
5
//
6
// Name: $Id: JMIAbstractMapper.java,v 1.11 2006/01/21 23:09:07 wfro Exp $
7
// Generated by: openMDX JMI Mapper
8
// Date: Mon Apr 03 11:38:57 CEST 2006
9
//
10
// GENERATED - DO NOT CHANGE MANUALLY
11
//
12
//////////////////////////////////////////////////////////////////////////////
13
package org.opencrx.kernel.depot1.cci;
14
15 public class DepotFilterImpl
16   extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17   implements DepotFilter {
18
19   public DepotFilterImpl(
20     org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21   ) {
22     super(
23       aPackage,
24       "org:opencrx:kernel:depot1:Depot",
25       null,
26       null
27     );
28   }
29
30   public DepotFilterImpl(
31     org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage,
32     org.openmdx.compatibility.base.query.FilterProperty[] filterProperties,
33     org.openmdx.compatibility.base.dataprovider.cci.AttributeSpecifier[] attributeSpecifiers
34   ) {
35     super(
36       aPackage,
37       "org:opencrx:kernel:depot1:Depot",
38       filterProperties,
39       attributeSpecifiers
40     );
41   }
42       
43 // ----------------------------------------------------------------------------
44
// Filter/ImplAttributeIsNotStruct
45
// ----------------------------------------------------------------------------
46
public void forAllAccessLevelBrowse (
47     short operator,
48     java.util.Collection JavaDoc values
49   ) {
50     refAddValue(
51       "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
52       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53       operator,
54       values
55     );
56   }
57
58   public void thereExistsAccessLevelBrowse (
59     short operator,
60     java.util.Collection JavaDoc values
61   ) {
62     refAddValue(
63       "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
64       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65       operator,
66       values
67     );
68   }
69
70   public void forAllAccessLevelBrowse (
71     short operator,
72     short[] filterValues
73   ) {
74     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
75     for(int i = 0; i < filterValues.length; i++) {
76       arrayAsList.add(
77         new Short JavaDoc(filterValues[i])
78       );
79     }
80     forAllAccessLevelBrowse (
81       operator,
82       arrayAsList
83     );
84   }
85
86   public void thereExistsAccessLevelBrowse (
87     short operator,
88     short[] filterValues
89   ) {
90     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
91     for(int i = 0; i < filterValues.length; i++) {
92       arrayAsList.add(
93         new Short JavaDoc(filterValues[i])
94       );
95     }
96     thereExistsAccessLevelBrowse (
97       operator,
98       arrayAsList
99     );
100   }
101
102   public void orderByAccessLevelBrowse (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112
// Filter/ImplAttributeIsNotStruct
113
// ----------------------------------------------------------------------------
114
public void forAllAccessLevelDelete (
115     short operator,
116     java.util.Collection JavaDoc values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125
126   public void thereExistsAccessLevelDelete (
127     short operator,
128     java.util.Collection JavaDoc values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137
138   public void forAllAccessLevelDelete (
139     short operator,
140     short[] filterValues
141   ) {
142     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
143     for(int i = 0; i < filterValues.length; i++) {
144       arrayAsList.add(
145         new Short JavaDoc(filterValues[i])
146       );
147     }
148     forAllAccessLevelDelete (
149       operator,
150       arrayAsList
151     );
152   }
153
154   public void thereExistsAccessLevelDelete (
155     short operator,
156     short[] filterValues
157   ) {
158     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
159     for(int i = 0; i < filterValues.length; i++) {
160       arrayAsList.add(
161         new Short JavaDoc(filterValues[i])
162       );
163     }
164     thereExistsAccessLevelDelete (
165       operator,
166       arrayAsList
167     );
168   }
169
170   public void orderByAccessLevelDelete (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180
// Filter/ImplAttributeIsNotStruct
181
// ----------------------------------------------------------------------------
182
public void forAllAccessLevelUpdate (
183     short operator,
184     java.util.Collection JavaDoc values
185   ) {
186     refAddValue(
187       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
188       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
189       operator,
190       values
191     );
192   }
193
194   public void thereExistsAccessLevelUpdate (
195     short operator,
196     java.util.Collection JavaDoc values
197   ) {
198     refAddValue(
199       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
200       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
201       operator,
202       values
203     );
204   }
205
206   public void forAllAccessLevelUpdate (
207     short operator,
208     short[] filterValues
209   ) {
210     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
211     for(int i = 0; i < filterValues.length; i++) {
212       arrayAsList.add(
213         new Short JavaDoc(filterValues[i])
214       );
215     }
216     forAllAccessLevelUpdate (
217       operator,
218       arrayAsList
219     );
220   }
221
222   public void thereExistsAccessLevelUpdate (
223     short operator,
224     short[] filterValues
225   ) {
226     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
227     for(int i = 0; i < filterValues.length; i++) {
228       arrayAsList.add(
229         new Short JavaDoc(filterValues[i])
230       );
231     }
232     thereExistsAccessLevelUpdate (
233       operator,
234       arrayAsList
235     );
236   }
237
238   public void orderByAccessLevelUpdate (
239     short order
240   ) {
241     refAddValue(
242       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
243       order
244     );
245   }
246       
247 // ----------------------------------------------------------------------------
248
// Filter/ImplAttributeIsNotStruct
249
// ----------------------------------------------------------------------------
250
public void forAllOwner (
251     short operator,
252     java.util.Collection JavaDoc values
253   ) {
254     refAddValue(
255       "org:opencrx:kernel:base:SecureObject:owner",
256       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
257       operator,
258       values
259     );
260   }
261
262   public void thereExistsOwner (
263     short operator,
264     java.util.Collection JavaDoc values
265   ) {
266     refAddValue(
267       "org:opencrx:kernel:base:SecureObject:owner",
268       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
269       operator,
270       values
271     );
272   }
273
274   public void forAllOwner (
275     short operator,
276     String JavaDoc[] filterValues
277   ) {
278     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
279     for(int i = 0; i < filterValues.length; i++) {
280       arrayAsList.add(
281         filterValues[i]
282       );
283     }
284     forAllOwner (
285       operator,
286       arrayAsList
287     );
288   }
289
290   public void thereExistsOwner (
291     short operator,
292     String JavaDoc[] filterValues
293   ) {
294     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
295     for(int i = 0; i < filterValues.length; i++) {
296       arrayAsList.add(
297         filterValues[i]
298       );
299     }
300     thereExistsOwner (
301       operator,
302       arrayAsList
303     );
304   }
305
306   public void orderByOwner (
307     short order
308   ) {
309     refAddValue(
310       "org:opencrx:kernel:base:SecureObject:owner",
311       order
312     );
313   }
314       
315 // ----------------------------------------------------------------------------
316
// Filter/ImplReference
317
// ----------------------------------------------------------------------------
318
public void forAllOwningGroup (
319     short operator,
320     org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
321   ) {
322     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
323     for(int i = 0; i < filterValues.length; i++) {
324       arrayAsList.add(
325         filterValues[i]
326       );
327     }
328     forAllOwningGroup (
329       operator,
330       arrayAsList
331     );
332   }
333
334   public void thereExistsOwningGroup (
335     short operator,
336     org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
337   ) {
338     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
339     for(int i = 0; i < filterValues.length; i++) {
340       arrayAsList.add(
341         filterValues[i]
342       );
343     }
344     thereExistsOwningGroup (
345       operator,
346       arrayAsList
347     );
348   }
349
350   public void forAllOwningGroup (
351     short operator,
352     java.util.Collection JavaDoc values
353   ) {
354     refAddValue(
355       "org:opencrx:kernel:base:SecureObject:owningGroup",
356       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
357       operator,
358       values
359     );
360   }
361
362   public void thereExistsOwningGroup (
363     short operator,
364     java.util.Collection JavaDoc values
365   ) {
366     refAddValue(
367       "org:opencrx:kernel:base:SecureObject:owningGroup",
368       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
369       operator,
370       values
371     );
372   }
373       
374 // ----------------------------------------------------------------------------
375
// Filter/ImplReference
376
// ----------------------------------------------------------------------------
377
public void forAllOwningUser (
378     short operator,
379     org.opencrx.security.realm1.cci.User[] filterValues
380   ) {
381     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
382     for(int i = 0; i < filterValues.length; i++) {
383       arrayAsList.add(
384         filterValues[i]
385       );
386     }
387     forAllOwningUser (
388       operator,
389       arrayAsList
390     );
391   }
392
393   public void thereExistsOwningUser (
394     short operator,
395     org.opencrx.security.realm1.cci.User[] filterValues
396   ) {
397     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
398     for(int i = 0; i < filterValues.length; i++) {
399       arrayAsList.add(
400         filterValues[i]
401       );
402     }
403     thereExistsOwningUser (
404       operator,
405       arrayAsList
406     );
407   }
408
409   public void forAllOwningUser (
410     short operator,
411     java.util.Collection JavaDoc values
412   ) {
413     refAddValue(
414       "org:opencrx:kernel:base:SecureObject:owningUser",
415       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
416       operator,
417       values
418     );
419   }
420
421   public void thereExistsOwningUser (
422     short operator,
423     java.util.Collection JavaDoc values
424   ) {
425     refAddValue(
426       "org:opencrx:kernel:base:SecureObject:owningUser",
427       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
428       operator,
429       values
430     );
431   }
432       
433 // ----------------------------------------------------------------------------
434
// Filter/ImplReference
435
// ----------------------------------------------------------------------------
436
public void forAllContract (
437     short operator,
438     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
439   ) {
440     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
441     for(int i = 0; i < filterValues.length; i++) {
442       arrayAsList.add(
443         filterValues[i]
444       );
445     }
446     forAllContract (
447       operator,
448       arrayAsList
449     );
450   }
451
452   public void thereExistsContract (
453     short operator,
454     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
455   ) {
456     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
457     for(int i = 0; i < filterValues.length; i++) {
458       arrayAsList.add(
459         filterValues[i]
460       );
461     }
462     thereExistsContract (
463       operator,
464       arrayAsList
465     );
466   }
467
468   public void forAllContract (
469     short operator,
470     java.util.Collection JavaDoc values
471   ) {
472     refAddValue(
473       "org:opencrx:kernel:contract1:ContractReferenceHolder:contract",
474       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
475       operator,
476       values
477     );
478   }
479
480   public void thereExistsContract (
481     short operator,
482     java.util.Collection JavaDoc values
483   ) {
484     refAddValue(
485       "org:opencrx:kernel:contract1:ContractReferenceHolder:contract",
486       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
487       operator,
488       values
489     );
490   }
491       
492 // ----------------------------------------------------------------------------
493
// Filter/ImplAttributeIsNotStruct
494
// ----------------------------------------------------------------------------
495
public void forAllAllowPositionAutoCreate (
496     short operator,
497     java.util.Collection JavaDoc values
498   ) {
499     refAddValue(
500       "org:opencrx:kernel:depot1:Depot:allowPositionAutoCreate",
501       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
502       operator,
503       values
504     );
505   }
506
507   public void thereExistsAllowPositionAutoCreate (
508     short operator,
509     java.util.Collection JavaDoc values
510   ) {
511     refAddValue(
512       "org:opencrx:kernel:depot1:Depot:allowPositionAutoCreate",
513       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
514       operator,
515       values
516     );
517   }
518
519   public void forAllAllowPositionAutoCreate (
520     short operator,
521     boolean[] filterValues
522   ) {
523     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
524     for(int i = 0; i < filterValues.length; i++) {
525       arrayAsList.add(
526         new Boolean JavaDoc(filterValues[i])
527       );
528     }
529     forAllAllowPositionAutoCreate (
530       operator,
531       arrayAsList
532     );
533   }
534
535   public void thereExistsAllowPositionAutoCreate (
536     short operator,
537     boolean[] filterValues
538   ) {
539     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
540     for(int i = 0; i < filterValues.length; i++) {
541       arrayAsList.add(
542         new Boolean JavaDoc(filterValues[i])
543       );
544     }
545     thereExistsAllowPositionAutoCreate (
546       operator,
547       arrayAsList
548     );
549   }
550
551   public void orderByAllowPositionAutoCreate (
552     short order
553   ) {
554     refAddValue(
555       "org:opencrx:kernel:depot1:Depot:allowPositionAutoCreate",
556       order
557     );
558   }
559       
560 // ----------------------------------------------------------------------------
561
// Filter/ImplAttributeIsNotStruct
562
// ----------------------------------------------------------------------------
563
public void forAllClosingDate (
564     short operator,
565     java.util.Collection JavaDoc values
566   ) {
567     refAddValue(
568       "org:opencrx:kernel:depot1:Depot:closingDate",
569       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
570       operator,
571       values
572     );
573   }
574
575   public void thereExistsClosingDate (
576     short operator,
577     java.util.Collection JavaDoc values
578   ) {
579     refAddValue(
580       "org:opencrx:kernel:depot1:Depot:closingDate",
581       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
582       operator,
583       values
584     );
585   }
586
587   public void forAllClosingDate (
588     short operator,
589     java.util.Date JavaDoc[] filterValues
590   ) {
591     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
592     for(int i = 0; i < filterValues.length; i++) {
593       arrayAsList.add(
594         filterValues[i]
595       );
596     }
597     forAllClosingDate (
598       operator,
599       arrayAsList
600     );
601   }
602
603   public void thereExistsClosingDate (
604     short operator,
605     java.util.Date JavaDoc[] filterValues
606   ) {
607     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
608     for(int i = 0; i < filterValues.length; i++) {
609       arrayAsList.add(
610         filterValues[i]
611       );
612     }
613     thereExistsClosingDate (
614       operator,
615       arrayAsList
616     );
617   }
618
619   public void orderByClosingDate (
620     short order
621   ) {
622     refAddValue(
623       "org:opencrx:kernel:depot1:Depot:closingDate",
624       order
625     );
626   }
627       
628 // ----------------------------------------------------------------------------
629
// Filter/ImplReference
630
// ----------------------------------------------------------------------------
631
public void forAllDepotGroup (
632     short operator,
633     org.opencrx.kernel.depot1.cci.DepotGroup[] filterValues
634   ) {
635     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
636     for(int i = 0; i < filterValues.length; i++) {
637       arrayAsList.add(
638         filterValues[i]
639       );
640     }
641     forAllDepotGroup (
642       operator,
643       arrayAsList
644     );
645   }
646
647   public void thereExistsDepotGroup (
648     short operator,
649     org.opencrx.kernel.depot1.cci.DepotGroup[] filterValues
650   ) {
651     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
652     for(int i = 0; i < filterValues.length; i++) {
653       arrayAsList.add(
654         filterValues[i]
655       );
656     }
657     thereExistsDepotGroup (
658       operator,
659       arrayAsList
660     );
661   }
662
663   public void forAllDepotGroup (
664     short operator,
665     java.util.Collection JavaDoc values
666   ) {
667     refAddValue(
668       "org:opencrx:kernel:depot1:Depot:depotGroup",
669       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
670       operator,
671       values
672     );
673   }
674
675   public void thereExistsDepotGroup (
676     short operator,
677     java.util.Collection JavaDoc values
678   ) {
679     refAddValue(
680       "org:opencrx:kernel:depot1:Depot:depotGroup",
681       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
682       operator,
683       values
684     );
685   }
686       
687 // ----------------------------------------------------------------------------
688
// Filter/ImplAttributeIsNotStruct
689
// ----------------------------------------------------------------------------
690
public void forAllDepotNumber (
691     short operator,
692     java.util.Collection JavaDoc values
693   ) {
694     refAddValue(
695       "org:opencrx:kernel:depot1:Depot:depotNumber",
696       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
697       operator,
698       values
699     );
700   }
701
702   public void thereExistsDepotNumber (
703     short operator,
704     java.util.Collection JavaDoc values
705   ) {
706     refAddValue(
707       "org:opencrx:kernel:depot1:Depot:depotNumber",
708       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
709       operator,
710       values
711     );
712   }
713
714   public void forAllDepotNumber (
715     short operator,
716     String JavaDoc[] filterValues
717   ) {
718     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
719     for(int i = 0; i < filterValues.length; i++) {
720       arrayAsList.add(
721         filterValues[i]
722       );
723     }
724     forAllDepotNumber (
725       operator,
726       arrayAsList
727     );
728   }
729
730   public void thereExistsDepotNumber (
731     short operator,
732     String JavaDoc[] filterValues
733   ) {
734     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
735     for(int i = 0; i < filterValues.length; i++) {
736       arrayAsList.add(
737         filterValues[i]
738       );
739     }
740     thereExistsDepotNumber (
741       operator,
742       arrayAsList
743     );
744   }
745
746   public void orderByDepotNumber (
747     short order
748   ) {
749     refAddValue(
750       "org:opencrx:kernel:depot1:Depot:depotNumber",
751       order
752     );
753   }
754       
755 // ----------------------------------------------------------------------------
756
// Filter/ImplReference
757
// ----------------------------------------------------------------------------
758
public void forAllDepotType (
759     short operator,
760     org.opencrx.kernel.depot1.cci.DepotType[] filterValues
761   ) {
762     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
763     for(int i = 0; i < filterValues.length; i++) {
764       arrayAsList.add(
765         filterValues[i]
766       );
767     }
768     forAllDepotType (
769       operator,
770       arrayAsList
771     );
772   }
773
774   public void thereExistsDepotType (
775     short operator,
776     org.opencrx.kernel.depot1.cci.DepotType[] filterValues
777   ) {
778     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
779     for(int i = 0; i < filterValues.length; i++) {
780       arrayAsList.add(
781         filterValues[i]
782       );
783     }
784     thereExistsDepotType (
785       operator,
786       arrayAsList
787     );
788   }
789
790   public void forAllDepotType (
791     short operator,
792     java.util.Collection JavaDoc values
793   ) {
794     refAddValue(
795       "org:opencrx:kernel:depot1:Depot:depotType",
796       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
797       operator,
798       values
799     );
800   }
801
802   public void thereExistsDepotType (
803     short operator,
804     java.util.Collection JavaDoc values
805   ) {
806     refAddValue(
807       "org:opencrx:kernel:depot1:Depot:depotType",
808       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
809       operator,
810       values
811     );
812   }
813       
814 // ----------------------------------------------------------------------------
815
// Filter/ImplAttributeIsNotStruct
816
// ----------------------------------------------------------------------------
817
public void forAllDescription (
818     short operator,
819     java.util.Collection JavaDoc values
820   ) {
821     refAddValue(
822       "org:opencrx:kernel:depot1:Depot:description",
823       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
824       operator,
825       values
826     );
827   }
828
829   public void thereExistsDescription (
830     short operator,
831     java.util.Collection JavaDoc values
832   ) {
833     refAddValue(
834       "org:opencrx:kernel:depot1:Depot:description",
835       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
836       operator,
837       values
838     );
839   }
840
841   public void forAllDescription (
842     short operator,
843     String JavaDoc[] filterValues
844   ) {
845     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
846     for(int i = 0; i < filterValues.length; i++) {
847       arrayAsList.add(
848         filterValues[i]
849       );
850     }
851     forAllDescription (
852       operator,
853       arrayAsList
854     );
855   }
856
857   public void thereExistsDescription (
858     short operator,
859     String JavaDoc[] filterValues
860   ) {
861     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
862     for(int i = 0; i < filterValues.length; i++) {
863       arrayAsList.add(
864         filterValues[i]
865       );
866     }
867     thereExistsDescription (
868       operator,
869       arrayAsList
870     );
871   }
872
873   public void orderByDescription (
874     short order
875   ) {
876     refAddValue(
877       "org:opencrx:kernel:depot1:Depot:description",
878       order
879     );
880   }
881       
882 // ----------------------------------------------------------------------------
883
// Filter/ImplAttributeIsNotStruct
884
// ----------------------------------------------------------------------------
885
public void forAllIsDefault (
886     short operator,
887     java.util.Collection JavaDoc values
888   ) {
889     refAddValue(
890       "org:opencrx:kernel:depot1:Depot:isDefault",
891       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
892       operator,
893       values
894     );
895   }
896
897   public void thereExistsIsDefault (
898     short operator,
899     java.util.Collection JavaDoc values
900   ) {
901     refAddValue(
902       "org:opencrx:kernel:depot1:Depot:isDefault",
903       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
904       operator,
905       values
906     );
907   }
908
909   public void forAllIsDefault (
910     short operator,
911     boolean[] filterValues
912   ) {
913     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
914     for(int i = 0; i < filterValues.length; i++) {
915       arrayAsList.add(
916         new Boolean JavaDoc(filterValues[i])
917       );
918     }
919     forAllIsDefault (
920       operator,
921       arrayAsList
922     );
923   }
924
925   public void thereExistsIsDefault (
926     short operator,
927     boolean[] filterValues
928   ) {
929     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
930     for(int i = 0; i < filterValues.length; i++) {
931       arrayAsList.add(
932         new Boolean JavaDoc(filterValues[i])
933       );
934     }
935     thereExistsIsDefault (
936       operator,
937       arrayAsList
938     );
939   }
940
941   public void orderByIsDefault (
942     short order
943   ) {
944     refAddValue(
945       "org:opencrx:kernel:depot1:Depot:isDefault",
946       order
947     );
948   }
949       
950 // ----------------------------------------------------------------------------
951
// Filter/ImplAttributeIsNotStruct
952
// ----------------------------------------------------------------------------
953
public void forAllIsLocked (
954     short operator,
955     java.util.Collection JavaDoc values
956   ) {
957     refAddValue(
958       "org:opencrx:kernel:depot1:Depot:isLocked",
959       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
960       operator,
961       values
962     );
963   }
964
965   public void thereExistsIsLocked (
966     short operator,
967     java.util.Collection JavaDoc values
968   ) {
969     refAddValue(
970       "org:opencrx:kernel:depot1:Depot:isLocked",
971       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
972       operator,
973       values
974     );
975   }
976
977   public void forAllIsLocked (
978     short operator,
979     boolean[] filterValues
980   ) {
981     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
982     for(int i = 0; i < filterValues.length; i++) {
983       arrayAsList.add(
984         new Boolean JavaDoc(filterValues[i])
985       );
986     }
987     forAllIsLocked (
988       operator,
989       arrayAsList
990     );
991   }
992
993   public void thereExistsIsLocked (
994     short operator,
995     boolean[] filterValues
996   ) {
997     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
998     for(int i = 0; i < filterValues.length; i++) {
999       arrayAsList.add(
1000        new Boolean JavaDoc(filterValues[i])
1001      );
1002    }
1003    thereExistsIsLocked (
1004      operator,
1005      arrayAsList
1006    );
1007  }
1008
1009  public void orderByIsLocked (
1010    short order
1011  ) {
1012    refAddValue(
1013      "org:opencrx:kernel:depot1:Depot:isLocked",
1014      order
1015    );
1016  }
1017      
1018// ----------------------------------------------------------------------------
1019
// Filter/ImplReference
1020
// ----------------------------------------------------------------------------
1021
public void forAllLatestReport (
1022    short operator,
1023    org.opencrx.kernel.depot1.cci.DepotReport[] filterValues
1024  ) {
1025    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1026    for(int i = 0; i < filterValues.length; i++) {
1027      arrayAsList.add(
1028        filterValues[i]
1029      );
1030    }
1031    forAllLatestReport (
1032      operator,
1033      arrayAsList
1034    );
1035  }
1036
1037  public void thereExistsLatestReport (
1038    short operator,
1039    org.opencrx.kernel.depot1.cci.DepotReport[] filterValues
1040  ) {
1041    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1042    for(int i = 0; i < filterValues.length; i++) {
1043      arrayAsList.add(
1044        filterValues[i]
1045      );
1046    }
1047    thereExistsLatestReport (
1048      operator,
1049      arrayAsList
1050    );
1051  }
1052
1053  public void forAllLatestReport (
1054    short operator,
1055    java.util.Collection JavaDoc values
1056  ) {
1057    refAddValue(
1058      "org:opencrx:kernel:depot1:Depot:latestReport",
1059      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1060      operator,
1061      values
1062    );
1063  }
1064
1065  public void thereExistsLatestReport (
1066    short operator,
1067    java.util.Collection JavaDoc values
1068  ) {
1069    refAddValue(
1070      "org:opencrx:kernel:depot1:Depot:latestReport",
1071      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1072      operator,
1073      values
1074    );
1075  }
1076      
1077// ----------------------------------------------------------------------------
1078
// Filter/ImplAttributeIsNotStruct
1079
// ----------------------------------------------------------------------------
1080
public void forAllName (
1081    short operator,
1082    java.util.Collection JavaDoc values
1083  ) {
1084    refAddValue(
1085      "org:opencrx:kernel:depot1:Depot:name",
1086      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1087      operator,
1088      values
1089    );
1090  }
1091
1092  public void thereExistsName (
1093    short operator,
1094    java.util.Collection JavaDoc values
1095  ) {
1096    refAddValue(
1097      "org:opencrx:kernel:depot1:Depot:name",
1098      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1099      operator,
1100      values
1101    );
1102  }
1103
1104  public void forAllName (
1105    short operator,
1106    String JavaDoc[] filterValues
1107  ) {
1108    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1109    for(int i = 0; i < filterValues.length; i++) {
1110      arrayAsList.add(
1111        filterValues[i]
1112      );
1113    }
1114    forAllName (
1115      operator,
1116      arrayAsList
1117    );
1118  }
1119
1120  public void thereExistsName (
1121    short operator,
1122    String JavaDoc[] filterValues
1123  ) {
1124    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1125    for(int i = 0; i < filterValues.length; i++) {
1126      arrayAsList.add(
1127        filterValues[i]
1128      );
1129    }
1130    thereExistsName (
1131      operator,
1132      arrayAsList
1133    );
1134  }
1135
1136  public void orderByName (
1137    short order
1138  ) {
1139    refAddValue(
1140      "org:opencrx:kernel:depot1:Depot:name",
1141      order
1142    );
1143  }
1144      
1145// ----------------------------------------------------------------------------
1146
// Filter/ImplAttributeIsNotStruct
1147
// ----------------------------------------------------------------------------
1148
public void forAllOpeningDate (
1149    short operator,
1150    java.util.Collection JavaDoc values
1151  ) {
1152    refAddValue(
1153      "org:opencrx:kernel:depot1:Depot:openingDate",
1154      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1155      operator,
1156      values
1157    );
1158  }
1159
1160  public void thereExistsOpeningDate (
1161    short operator,
1162    java.util.Collection JavaDoc values
1163  ) {
1164    refAddValue(
1165      "org:opencrx:kernel:depot1:Depot:openingDate",
1166      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1167      operator,
1168      values
1169    );
1170  }
1171
1172  public void forAllOpeningDate (
1173    short operator,
1174    java.util.Date JavaDoc[] filterValues
1175  ) {
1176    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1177    for(int i = 0; i < filterValues.length; i++) {
1178      arrayAsList.add(
1179        filterValues[i]
1180      );
1181    }
1182    forAllOpeningDate (
1183      operator,
1184      arrayAsList
1185    );
1186  }
1187
1188  public void thereExistsOpeningDate (
1189    short operator,
1190    java.util.Date JavaDoc[] filterValues
1191  ) {
1192    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1193    for(int i = 0; i < filterValues.length; i++) {
1194      arrayAsList.add(
1195        filterValues[i]
1196      );
1197    }
1198    thereExistsOpeningDate (
1199      operator,
1200      arrayAsList
1201    );
1202  }
1203
1204  public void orderByOpeningDate (
1205    short order
1206  ) {
1207    refAddValue(
1208      "org:opencrx:kernel:depot1:Depot:openingDate",
1209      order
1210    );
1211  }
1212      
1213// ----------------------------------------------------------------------------
1214
// Filter/ImplAttributeIsNotStruct
1215
// ----------------------------------------------------------------------------
1216
public void forAllCategory (
1217    short operator,
1218    java.util.Collection JavaDoc values
1219  ) {
1220    refAddValue(
1221      "org:opencrx:kernel:generic:CrxObject:category",
1222      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1223      operator,
1224      values
1225    );
1226  }
1227
1228  public void thereExistsCategory (
1229    short operator,
1230    java.util.Collection JavaDoc values
1231  ) {
1232    refAddValue(
1233      "org:opencrx:kernel:generic:CrxObject:category",
1234      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1235      operator,
1236      values
1237    );
1238  }
1239
1240  public void forAllCategory (
1241    short operator,
1242    String JavaDoc[] filterValues
1243  ) {
1244    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1245    for(int i = 0; i < filterValues.length; i++) {
1246      arrayAsList.add(
1247        filterValues[i]
1248      );
1249    }
1250    forAllCategory (
1251      operator,
1252      arrayAsList
1253    );
1254  }
1255
1256  public void thereExistsCategory (
1257    short operator,
1258    String JavaDoc[] filterValues
1259  ) {
1260    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1261    for(int i = 0; i < filterValues.length; i++) {
1262      arrayAsList.add(
1263        filterValues[i]
1264      );
1265    }
1266    thereExistsCategory (
1267      operator,
1268      arrayAsList
1269    );
1270  }
1271
1272  public void orderByCategory (
1273    short order
1274  ) {
1275    refAddValue(
1276      "org:opencrx:kernel:generic:CrxObject:category",
1277      order
1278    );
1279  }
1280      
1281// ----------------------------------------------------------------------------
1282
// Filter/ImplAttributeIsNotStruct
1283
// ----------------------------------------------------------------------------
1284
public void forAllDisabled (
1285    short operator,
1286    java.util.Collection JavaDoc values
1287  ) {
1288    refAddValue(
1289      "org:opencrx:kernel:generic:CrxObject:disabled",
1290      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1291      operator,
1292      values
1293    );
1294  }
1295
1296  public void thereExistsDisabled (
1297    short operator,
1298    java.util.Collection JavaDoc values
1299  ) {
1300    refAddValue(
1301      "org:opencrx:kernel:generic:CrxObject:disabled",
1302      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1303      operator,
1304      values
1305    );
1306  }
1307
1308  public void forAllDisabled (
1309    short operator,
1310    boolean[] filterValues
1311  ) {
1312    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1313    for(int i = 0; i < filterValues.length; i++) {
1314      arrayAsList.add(
1315        new Boolean JavaDoc(filterValues[i])
1316      );
1317    }
1318    forAllDisabled (
1319      operator,
1320      arrayAsList
1321    );
1322  }
1323
1324  public void thereExistsDisabled (
1325    short operator,
1326    boolean[] filterValues
1327  ) {
1328    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1329    for(int i = 0; i < filterValues.length; i++) {
1330      arrayAsList.add(
1331        new Boolean JavaDoc(filterValues[i])
1332      );
1333    }
1334    thereExistsDisabled (
1335      operator,
1336      arrayAsList
1337    );
1338  }
1339
1340  public void orderByDisabled (
1341    short order
1342  ) {
1343    refAddValue(
1344      "org:opencrx:kernel:generic:CrxObject:disabled",
1345      order
1346    );
1347  }
1348      
1349// ----------------------------------------------------------------------------
1350
// Filter/ImplAttributeIsNotStruct
1351
// ----------------------------------------------------------------------------
1352
public void forAllDisabledReason (
1353    short operator,
1354    java.util.Collection JavaDoc values
1355  ) {
1356    refAddValue(
1357      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1358      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1359      operator,
1360      values
1361    );
1362  }
1363
1364  public void thereExistsDisabledReason (
1365    short operator,
1366    java.util.Collection JavaDoc values
1367  ) {
1368    refAddValue(
1369      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1370      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1371      operator,
1372      values
1373    );
1374  }
1375
1376  public void forAllDisabledReason (
1377    short operator,
1378    String JavaDoc[] filterValues
1379  ) {
1380    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1381    for(int i = 0; i < filterValues.length; i++) {
1382      arrayAsList.add(
1383        filterValues[i]
1384      );
1385    }
1386    forAllDisabledReason (
1387      operator,
1388      arrayAsList
1389    );
1390  }
1391
1392  public void thereExistsDisabledReason (
1393    short operator,
1394    String JavaDoc[] filterValues
1395  ) {
1396    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1397    for(int i = 0; i < filterValues.length; i++) {
1398      arrayAsList.add(
1399        filterValues[i]
1400      );
1401    }
1402    thereExistsDisabledReason (
1403      operator,
1404      arrayAsList
1405    );
1406  }
1407
1408  public void orderByDisabledReason (
1409    short order
1410  ) {
1411    refAddValue(
1412      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1413      order
1414    );
1415  }
1416      
1417// ----------------------------------------------------------------------------
1418
// Filter/ImplAttributeIsNotStruct
1419
// ----------------------------------------------------------------------------
1420
public void forAllExternalLink (
1421    short operator,
1422    java.util.Collection JavaDoc values
1423  ) {
1424    refAddValue(
1425      "org:opencrx:kernel:generic:CrxObject:externalLink",
1426      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1427      operator,
1428      values
1429    );
1430  }
1431
1432  public void thereExistsExternalLink (
1433    short operator,
1434    java.util.Collection JavaDoc values
1435  ) {
1436    refAddValue(
1437      "org:opencrx:kernel:generic:CrxObject:externalLink",
1438      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1439      operator,
1440      values
1441    );
1442  }
1443
1444  public void forAllExternalLink (
1445    short operator,
1446    String JavaDoc[] filterValues
1447  ) {
1448    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1449    for(int i = 0; i < filterValues.length; i++) {
1450      arrayAsList.add(
1451        filterValues[i]
1452      );
1453    }
1454    forAllExternalLink (
1455      operator,
1456      arrayAsList
1457    );
1458  }
1459
1460  public void thereExistsExternalLink (
1461    short operator,
1462    String JavaDoc[] filterValues
1463  ) {
1464    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1465    for(int i = 0; i < filterValues.length; i++) {
1466      arrayAsList.add(
1467        filterValues[i]
1468      );
1469    }
1470    thereExistsExternalLink (
1471      operator,
1472      arrayAsList
1473    );
1474  }
1475
1476  public void orderByExternalLink (
1477    short order
1478  ) {
1479    refAddValue(
1480      "org:opencrx:kernel:generic:CrxObject:externalLink",
1481      order
1482    );
1483  }
1484      
1485// ----------------------------------------------------------------------------
1486
// Filter/ImplAttributeIsNotStruct
1487
// ----------------------------------------------------------------------------
1488
public void forAllUserBoolean0 (
1489    short operator,
1490    java.util.Collection JavaDoc values
1491  ) {
1492    refAddValue(
1493      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1494      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1495      operator,
1496      values
1497    );
1498  }
1499
1500  public void thereExistsUserBoolean0 (
1501    short operator,
1502    java.util.Collection JavaDoc values
1503  ) {
1504    refAddValue(
1505      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1506      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1507      operator,
1508      values
1509    );
1510  }
1511
1512  public void forAllUserBoolean0 (
1513    short operator,
1514    boolean[] filterValues
1515  ) {
1516    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1517    for(int i = 0; i < filterValues.length; i++) {
1518      arrayAsList.add(
1519        new Boolean JavaDoc(filterValues[i])
1520      );
1521    }
1522    forAllUserBoolean0 (
1523      operator,
1524      arrayAsList
1525    );
1526  }
1527
1528  public void thereExistsUserBoolean0 (
1529    short operator,
1530    boolean[] filterValues
1531  ) {
1532    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1533    for(int i = 0; i < filterValues.length; i++) {
1534      arrayAsList.add(
1535        new Boolean JavaDoc(filterValues[i])
1536      );
1537    }
1538    thereExistsUserBoolean0 (
1539      operator,
1540      arrayAsList
1541    );
1542  }
1543
1544  public void orderByUserBoolean0 (
1545    short order
1546  ) {
1547    refAddValue(
1548      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1549      order
1550    );
1551  }
1552      
1553// ----------------------------------------------------------------------------
1554
// Filter/ImplAttributeIsNotStruct
1555
// ----------------------------------------------------------------------------
1556
public void forAllUserBoolean1 (
1557    short operator,
1558    java.util.Collection JavaDoc values
1559  ) {
1560    refAddValue(
1561      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1562      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1563      operator,
1564      values
1565    );
1566  }
1567
1568  public void thereExistsUserBoolean1 (
1569    short operator,
1570    java.util.Collection JavaDoc values
1571  ) {
1572    refAddValue(
1573      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1574      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1575      operator,
1576      values
1577    );
1578  }
1579
1580  public void forAllUserBoolean1 (
1581    short operator,
1582    boolean[] filterValues
1583  ) {
1584    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1585    for(int i = 0; i < filterValues.length; i++) {
1586      arrayAsList.add(
1587        new Boolean JavaDoc(filterValues[i])
1588      );
1589    }
1590    forAllUserBoolean1 (
1591      operator,
1592      arrayAsList
1593    );
1594  }
1595
1596  public void thereExistsUserBoolean1 (
1597    short operator,
1598    boolean[] filterValues
1599  ) {
1600    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1601    for(int i = 0; i < filterValues.length; i++) {
1602      arrayAsList.add(
1603        new Boolean JavaDoc(filterValues[i])
1604      );
1605    }
1606    thereExistsUserBoolean1 (
1607      operator,
1608      arrayAsList
1609    );
1610  }
1611
1612  public void orderByUserBoolean1 (
1613    short order
1614  ) {
1615    refAddValue(
1616      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1617      order
1618    );
1619  }
1620      
1621// ----------------------------------------------------------------------------
1622
// Filter/ImplAttributeIsNotStruct
1623
// ----------------------------------------------------------------------------
1624
public void forAllUserBoolean2 (
1625    short operator,
1626    java.util.Collection JavaDoc values
1627  ) {
1628    refAddValue(
1629      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1630      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1631      operator,
1632      values
1633    );
1634  }
1635
1636  public void thereExistsUserBoolean2 (
1637    short operator,
1638    java.util.Collection JavaDoc values
1639  ) {
1640    refAddValue(
1641      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1642      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1643      operator,
1644      values
1645    );
1646  }
1647
1648  public void forAllUserBoolean2 (
1649    short operator,
1650    boolean[] filterValues
1651  ) {
1652    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1653    for(int i = 0; i < filterValues.length; i++) {
1654      arrayAsList.add(
1655        new Boolean JavaDoc(filterValues[i])
1656      );
1657    }
1658    forAllUserBoolean2 (
1659      operator,
1660      arrayAsList
1661    );
1662  }
1663
1664  public void thereExistsUserBoolean2 (
1665    short operator,
1666    boolean[] filterValues
1667  ) {
1668    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1669    for(int i = 0; i < filterValues.length; i++) {
1670      arrayAsList.add(
1671        new Boolean JavaDoc(filterValues[i])
1672      );
1673    }
1674    thereExistsUserBoolean2 (
1675      operator,
1676      arrayAsList
1677    );
1678  }
1679
1680  public void orderByUserBoolean2 (
1681    short order
1682  ) {
1683    refAddValue(
1684      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1685      order
1686    );
1687  }
1688      
1689// ----------------------------------------------------------------------------
1690
// Filter/ImplAttributeIsNotStruct
1691
// ----------------------------------------------------------------------------
1692
public void forAllUserBoolean3 (
1693    short operator,
1694    java.util.Collection JavaDoc values
1695  ) {
1696    refAddValue(
1697      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1698      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1699      operator,
1700      values
1701    );
1702  }
1703
1704  public void thereExistsUserBoolean3 (
1705    short operator,
1706    java.util.Collection JavaDoc values
1707  ) {
1708    refAddValue(
1709      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1710      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1711      operator,
1712      values
1713    );
1714  }
1715
1716  public void forAllUserBoolean3 (
1717    short operator,
1718    boolean[] filterValues
1719  ) {
1720    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1721    for(int i = 0; i < filterValues.length; i++) {
1722      arrayAsList.add(
1723        new Boolean JavaDoc(filterValues[i])
1724      );
1725    }
1726    forAllUserBoolean3 (
1727      operator,
1728      arrayAsList
1729    );
1730  }
1731
1732  public void thereExistsUserBoolean3 (
1733    short operator,
1734    boolean[] filterValues
1735  ) {
1736    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1737    for(int i = 0; i < filterValues.length; i++) {
1738      arrayAsList.add(
1739        new Boolean JavaDoc(filterValues[i])
1740      );
1741    }
1742    thereExistsUserBoolean3 (
1743      operator,
1744      arrayAsList
1745    );
1746  }
1747
1748  public void orderByUserBoolean3 (
1749    short order
1750  ) {
1751    refAddValue(
1752      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1753      order
1754    );
1755  }
1756      
1757// ----------------------------------------------------------------------------
1758
// Filter/ImplAttributeIsNotStruct
1759
// ----------------------------------------------------------------------------
1760
public void forAllUserBoolean4 (
1761    short operator,
1762    java.util.Collection JavaDoc values
1763  ) {
1764    refAddValue(
1765      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1766      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1767      operator,
1768      values
1769    );
1770  }
1771
1772  public void thereExistsUserBoolean4 (
1773    short operator,
1774    java.util.Collection JavaDoc values
1775  ) {
1776    refAddValue(
1777      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1778      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1779      operator,
1780      values
1781    );
1782  }
1783
1784  public void forAllUserBoolean4 (
1785    short operator,
1786    boolean[] filterValues
1787  ) {
1788    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1789    for(int i = 0; i < filterValues.length; i++) {
1790      arrayAsList.add(
1791        new Boolean JavaDoc(filterValues[i])
1792      );
1793    }
1794    forAllUserBoolean4 (
1795      operator,
1796      arrayAsList
1797    );
1798  }
1799
1800  public void thereExistsUserBoolean4 (
1801    short operator,
1802    boolean[] filterValues
1803  ) {
1804    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1805    for(int i = 0; i < filterValues.length; i++) {
1806      arrayAsList.add(
1807        new Boolean JavaDoc(filterValues[i])
1808      );
1809    }
1810    thereExistsUserBoolean4 (
1811      operator,
1812      arrayAsList
1813    );
1814  }
1815
1816  public void orderByUserBoolean4 (
1817    short order
1818  ) {
1819    refAddValue(
1820      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1821      order
1822    );
1823  }
1824      
1825// ----------------------------------------------------------------------------
1826
// Filter/ImplAttributeIsNotStruct
1827
// ----------------------------------------------------------------------------
1828
public void forAllUserCode0 (
1829    short operator,
1830    java.util.Collection JavaDoc values
1831  ) {
1832    refAddValue(
1833      "org:opencrx:kernel:generic:CrxObject:userCode0",
1834      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1835      operator,
1836      values
1837    );
1838  }
1839
1840  public void thereExistsUserCode0 (
1841    short operator,
1842    java.util.Collection JavaDoc values
1843  ) {
1844    refAddValue(
1845      "org:opencrx:kernel:generic:CrxObject:userCode0",
1846      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1847      operator,
1848      values
1849    );
1850  }
1851
1852  public void forAllUserCode0 (
1853    short operator,
1854    short[] filterValues
1855  ) {
1856    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1857    for(int i = 0; i < filterValues.length; i++) {
1858      arrayAsList.add(
1859        new Short JavaDoc(filterValues[i])
1860      );
1861    }
1862    forAllUserCode0 (
1863      operator,
1864      arrayAsList
1865    );
1866  }
1867
1868  public void thereExistsUserCode0 (
1869    short operator,
1870    short[] filterValues
1871  ) {
1872    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1873    for(int i = 0; i < filterValues.length; i++) {
1874      arrayAsList.add(
1875        new Short JavaDoc(filterValues[i])
1876      );
1877    }
1878    thereExistsUserCode0 (
1879      operator,
1880      arrayAsList
1881    );
1882  }
1883
1884  public void orderByUserCode0 (
1885    short order
1886  ) {
1887    refAddValue(
1888      "org:opencrx:kernel:generic:CrxObject:userCode0",
1889      order
1890    );
1891  }
1892      
1893// ----------------------------------------------------------------------------
1894
// Filter/ImplAttributeIsNotStruct
1895
// ----------------------------------------------------------------------------
1896
public void forAllUserCode1 (
1897    short operator,
1898    java.util.Collection JavaDoc values
1899  ) {
1900    refAddValue(
1901      "org:opencrx:kernel:generic:CrxObject:userCode1",
1902      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1903      operator,
1904      values
1905    );
1906  }
1907
1908  public void thereExistsUserCode1 (
1909    short operator,
1910    java.util.Collection JavaDoc values
1911  ) {
1912    refAddValue(
1913      "org:opencrx:kernel:generic:CrxObject:userCode1",
1914      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1915      operator,
1916      values
1917    );
1918  }
1919
1920  public void forAllUserCode1 (
1921    short operator,
1922    short[] filterValues
1923  ) {
1924    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1925    for(int i = 0; i < filterValues.length; i++) {
1926      arrayAsList.add(
1927        new Short JavaDoc(filterValues[i])
1928      );
1929    }
1930    forAllUserCode1 (
1931      operator,
1932      arrayAsList
1933    );
1934  }
1935
1936  public void thereExistsUserCode1 (
1937    short operator,
1938    short[] filterValues
1939  ) {
1940    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1941    for(int i = 0; i < filterValues.length; i++) {
1942      arrayAsList.add(
1943        new Short JavaDoc(filterValues[i])
1944      );
1945    }
1946    thereExistsUserCode1 (
1947      operator,
1948      arrayAsList
1949    );
1950  }
1951
1952  public void orderByUserCode1 (
1953    short order
1954  ) {
1955    refAddValue(
1956      "org:opencrx:kernel:generic:CrxObject:userCode1",
1957      order
1958    );
1959  }
1960      
1961// ----------------------------------------------------------------------------
1962
// Filter/ImplAttributeIsNotStruct
1963
// ----------------------------------------------------------------------------
1964
public void forAllUserCode2 (
1965    short operator,
1966    java.util.Collection JavaDoc values
1967  ) {
1968    refAddValue(
1969      "org:opencrx:kernel:generic:CrxObject:userCode2",
1970      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1971      operator,
1972      values
1973    );
1974  }
1975
1976  public void thereExistsUserCode2 (
1977    short operator,
1978    java.util.Collection JavaDoc values
1979  ) {
1980    refAddValue(
1981      "org:opencrx:kernel:generic:CrxObject:userCode2",
1982      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1983      operator,
1984      values
1985    );
1986  }
1987
1988  public void forAllUserCode2 (
1989    short operator,
1990    short[] filterValues
1991  ) {
1992    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1993    for(int i = 0; i < filterValues.length; i++) {
1994      arrayAsList.add(
1995        new Short JavaDoc(filterValues[i])
1996      );
1997    }
1998    forAllUserCode2 (
1999      operator,
2000      arrayAsList
2001    );
2002  }
2003
2004  public void thereExistsUserCode2 (
2005    short operator,
2006    short[] filterValues
2007  ) {
2008    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2009    for(int i = 0; i < filterValues.length; i++) {
2010      arrayAsList.add(
2011        new Short JavaDoc(filterValues[i])
2012      );
2013    }
2014    thereExistsUserCode2 (
2015      operator,
2016      arrayAsList
2017    );
2018  }
2019
2020  public void orderByUserCode2 (
2021    short order
2022  ) {
2023    refAddValue(
2024      "org:opencrx:kernel:generic:CrxObject:userCode2",
2025      order
2026    );
2027  }
2028      
2029// ----------------------------------------------------------------------------
2030
// Filter/ImplAttributeIsNotStruct
2031
// ----------------------------------------------------------------------------
2032
public void forAllUserCode3 (
2033    short operator,
2034    java.util.Collection JavaDoc values
2035  ) {
2036    refAddValue(
2037      "org:opencrx:kernel:generic:CrxObject:userCode3",
2038      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2039      operator,
2040      values
2041    );
2042  }
2043
2044  public void thereExistsUserCode3 (
2045    short operator,
2046    java.util.Collection JavaDoc values
2047  ) {
2048    refAddValue(
2049      "org:opencrx:kernel:generic:CrxObject:userCode3",
2050      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2051      operator,
2052      values
2053    );
2054  }
2055
2056  public void forAllUserCode3 (
2057    short operator,
2058    short[] filterValues
2059  ) {
2060    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2061    for(int i = 0; i < filterValues.length; i++) {
2062      arrayAsList.add(
2063        new Short JavaDoc(filterValues[i])
2064      );
2065    }
2066    forAllUserCode3 (
2067      operator,
2068      arrayAsList
2069    );
2070  }
2071
2072  public void thereExistsUserCode3 (
2073    short operator,
2074    short[] filterValues
2075  ) {
2076    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2077    for(int i = 0; i < filterValues.length; i++) {
2078      arrayAsList.add(
2079        new Short JavaDoc(filterValues[i])
2080      );
2081    }
2082    thereExistsUserCode3 (
2083      operator,
2084      arrayAsList
2085    );
2086  }
2087
2088  public void orderByUserCode3 (
2089    short order
2090  ) {
2091    refAddValue(
2092      "org:opencrx:kernel:generic:CrxObject:userCode3",
2093      order
2094    );
2095  }
2096      
2097// ----------------------------------------------------------------------------
2098
// Filter/ImplAttributeIsNotStruct
2099
// ----------------------------------------------------------------------------
2100
public void forAllUserCode4 (
2101    short operator,
2102    java.util.Collection JavaDoc values
2103  ) {
2104    refAddValue(
2105      "org:opencrx:kernel:generic:CrxObject:userCode4",
2106      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2107      operator,
2108      values
2109    );
2110  }
2111
2112  public void thereExistsUserCode4 (
2113    short operator,
2114    java.util.Collection JavaDoc values
2115  ) {
2116    refAddValue(
2117      "org:opencrx:kernel:generic:CrxObject:userCode4",
2118      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2119      operator,
2120      values
2121    );
2122  }
2123
2124  public void forAllUserCode4 (
2125    short operator,
2126    short[] filterValues
2127  ) {
2128    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2129    for(int i = 0; i < filterValues.length; i++) {
2130      arrayAsList.add(
2131        new Short JavaDoc(filterValues[i])
2132      );
2133    }
2134    forAllUserCode4 (
2135      operator,
2136      arrayAsList
2137    );
2138  }
2139
2140  public void thereExistsUserCode4 (
2141    short operator,
2142    short[] filterValues
2143  ) {
2144    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2145    for(int i = 0; i < filterValues.length; i++) {
2146      arrayAsList.add(
2147        new Short JavaDoc(filterValues[i])
2148      );
2149    }
2150    thereExistsUserCode4 (
2151      operator,
2152      arrayAsList
2153    );
2154  }
2155
2156  public void orderByUserCode4 (
2157    short order
2158  ) {
2159    refAddValue(
2160      "org:opencrx:kernel:generic:CrxObject:userCode4",
2161      order
2162    );
2163  }
2164      
2165// ----------------------------------------------------------------------------
2166
// Filter/ImplAttributeIsNotStruct
2167
// ----------------------------------------------------------------------------
2168
public void forAllUserDate0 (
2169    short operator,
2170    java.util.Collection JavaDoc values
2171  ) {
2172    refAddValue(
2173      "org:opencrx:kernel:generic:CrxObject:userDate0",
2174      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2175      operator,
2176      values
2177    );
2178  }
2179
2180  public void thereExistsUserDate0 (
2181    short operator,
2182    java.util.Collection JavaDoc values
2183  ) {
2184    refAddValue(
2185      "org:opencrx:kernel:generic:CrxObject:userDate0",
2186      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2187      operator,
2188      values
2189    );
2190  }
2191
2192  public void forAllUserDate0 (
2193    short operator,
2194    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2195  ) {
2196    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2197    for(int i = 0; i < filterValues.length; i++) {
2198      arrayAsList.add(
2199        filterValues[i]
2200      );
2201    }
2202    forAllUserDate0 (
2203      operator,
2204      arrayAsList
2205    );
2206  }
2207
2208  public void thereExistsUserDate0 (
2209    short operator,
2210    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2211  ) {
2212    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2213    for(int i = 0; i < filterValues.length; i++) {
2214      arrayAsList.add(
2215        filterValues[i]
2216      );
2217    }
2218    thereExistsUserDate0 (
2219      operator,
2220      arrayAsList
2221    );
2222  }
2223
2224  public void orderByUserDate0 (
2225    short order
2226  ) {
2227    refAddValue(
2228      "org:opencrx:kernel:generic:CrxObject:userDate0",
2229      order
2230    );
2231  }
2232      
2233// ----------------------------------------------------------------------------
2234
// Filter/ImplAttributeIsNotStruct
2235
// ----------------------------------------------------------------------------
2236
public void forAllUserDate1 (
2237    short operator,
2238    java.util.Collection JavaDoc values
2239  ) {
2240    refAddValue(
2241      "org:opencrx:kernel:generic:CrxObject:userDate1",
2242      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2243      operator,
2244      values
2245    );
2246  }
2247
2248  public void thereExistsUserDate1 (
2249    short operator,
2250    java.util.Collection JavaDoc values
2251  ) {
2252    refAddValue(
2253      "org:opencrx:kernel:generic:CrxObject:userDate1",
2254      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2255      operator,
2256      values
2257    );
2258  }
2259
2260  public void forAllUserDate1 (
2261    short operator,
2262    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2263  ) {
2264    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2265    for(int i = 0; i < filterValues.length; i++) {
2266      arrayAsList.add(
2267        filterValues[i]
2268      );
2269    }
2270    forAllUserDate1 (
2271      operator,
2272      arrayAsList
2273    );
2274  }
2275
2276  public void thereExistsUserDate1 (
2277    short operator,
2278    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2279  ) {
2280    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2281    for(int i = 0; i < filterValues.length; i++) {
2282      arrayAsList.add(
2283        filterValues[i]
2284      );
2285    }
2286    thereExistsUserDate1 (
2287      operator,
2288      arrayAsList
2289    );
2290  }
2291
2292  public void orderByUserDate1 (
2293    short order
2294  ) {
2295    refAddValue(
2296      "org:opencrx:kernel:generic:CrxObject:userDate1",
2297      order
2298    );
2299  }
2300      
2301// ----------------------------------------------------------------------------
2302
// Filter/ImplAttributeIsNotStruct
2303
// ----------------------------------------------------------------------------
2304
public void forAllUserDate2 (
2305    short operator,
2306    java.util.Collection JavaDoc values
2307  ) {
2308    refAddValue(
2309      "org:opencrx:kernel:generic:CrxObject:userDate2",
2310      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2311      operator,
2312      values
2313    );
2314  }
2315
2316  public void thereExistsUserDate2 (
2317    short operator,
2318    java.util.Collection JavaDoc values
2319  ) {
2320    refAddValue(
2321      "org:opencrx:kernel:generic:CrxObject:userDate2",
2322      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2323      operator,
2324      values
2325    );
2326  }
2327
2328  public void forAllUserDate2 (
2329    short operator,
2330    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2331  ) {
2332    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2333    for(int i = 0; i < filterValues.length; i++) {
2334      arrayAsList.add(
2335        filterValues[i]
2336      );
2337    }
2338    forAllUserDate2 (
2339      operator,
2340      arrayAsList
2341    );
2342  }
2343
2344  public void thereExistsUserDate2 (
2345    short operator,
2346    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2347  ) {
2348    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2349    for(int i = 0; i < filterValues.length; i++) {
2350      arrayAsList.add(
2351        filterValues[i]
2352      );
2353    }
2354    thereExistsUserDate2 (
2355      operator,
2356      arrayAsList
2357    );
2358  }
2359
2360  public void orderByUserDate2 (
2361    short order
2362  ) {
2363    refAddValue(
2364      "org:opencrx:kernel:generic:CrxObject:userDate2",
2365      order
2366    );
2367  }
2368      
2369// ----------------------------------------------------------------------------
2370
// Filter/ImplAttributeIsNotStruct
2371
// ----------------------------------------------------------------------------
2372
public void forAllUserDate3 (
2373    short operator,
2374    java.util.Collection JavaDoc values
2375  ) {
2376    refAddValue(
2377      "org:opencrx:kernel:generic:CrxObject:userDate3",
2378      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2379      operator,
2380      values
2381    );
2382  }
2383
2384  public void thereExistsUserDate3 (
2385    short operator,
2386    java.util.Collection JavaDoc values
2387  ) {
2388    refAddValue(
2389      "org:opencrx:kernel:generic:CrxObject:userDate3",
2390      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2391      operator,
2392      values
2393    );
2394  }
2395
2396  public void forAllUserDate3 (
2397    short operator,
2398    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2399  ) {
2400    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2401    for(int i = 0; i < filterValues.length; i++) {
2402      arrayAsList.add(
2403        filterValues[i]
2404      );
2405    }
2406    forAllUserDate3 (
2407      operator,
2408      arrayAsList
2409    );
2410  }
2411
2412  public void thereExistsUserDate3 (
2413    short operator,
2414    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2415  ) {
2416    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2417    for(int i = 0; i < filterValues.length; i++) {
2418      arrayAsList.add(
2419        filterValues[i]
2420      );
2421    }
2422    thereExistsUserDate3 (
2423      operator,
2424      arrayAsList
2425    );
2426  }
2427
2428  public void orderByUserDate3 (
2429    short order
2430  ) {
2431    refAddValue(
2432      "org:opencrx:kernel:generic:CrxObject:userDate3",
2433      order
2434    );
2435  }
2436      
2437// ----------------------------------------------------------------------------
2438
// Filter/ImplAttributeIsNotStruct
2439
// ----------------------------------------------------------------------------
2440
public void forAllUserDate4 (
2441    short operator,
2442    java.util.Collection JavaDoc values
2443  ) {
2444    refAddValue(
2445      "org:opencrx:kernel:generic:CrxObject:userDate4",
2446      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2447      operator,
2448      values
2449    );
2450  }
2451
2452  public void thereExistsUserDate4 (
2453    short operator,
2454    java.util.Collection JavaDoc values
2455  ) {
2456    refAddValue(
2457      "org:opencrx:kernel:generic:CrxObject:userDate4",
2458      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2459      operator,
2460      values
2461    );
2462  }
2463
2464  public void forAllUserDate4 (
2465    short operator,
2466    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2467  ) {
2468    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2469    for(int i = 0; i < filterValues.length; i++) {
2470      arrayAsList.add(
2471        filterValues[i]
2472      );
2473    }
2474    forAllUserDate4 (
2475      operator,
2476      arrayAsList
2477    );
2478  }
2479
2480  public void thereExistsUserDate4 (
2481    short operator,
2482    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2483  ) {
2484    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2485    for(int i = 0; i < filterValues.length; i++) {
2486      arrayAsList.add(
2487        filterValues[i]
2488      );
2489    }
2490    thereExistsUserDate4 (
2491      operator,
2492      arrayAsList
2493    );
2494  }
2495
2496  public void orderByUserDate4 (
2497    short order
2498  ) {
2499    refAddValue(
2500      "org:opencrx:kernel:generic:CrxObject:userDate4",
2501      order
2502    );
2503  }
2504      
2505// ----------------------------------------------------------------------------
2506
// Filter/ImplAttributeIsNotStruct
2507
// ----------------------------------------------------------------------------
2508
public void forAllUserDateTime0 (
2509    short operator,
2510    java.util.Collection JavaDoc values
2511  ) {
2512    refAddValue(
2513      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2514      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2515      operator,
2516      values
2517    );
2518  }
2519
2520  public void thereExistsUserDateTime0 (
2521    short operator,
2522    java.util.Collection JavaDoc values
2523  ) {
2524    refAddValue(
2525      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2526      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2527      operator,
2528      values
2529    );
2530  }
2531
2532  public void forAllUserDateTime0 (
2533    short operator,
2534    java.util.Date JavaDoc[] filterValues
2535  ) {
2536    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2537    for(int i = 0; i < filterValues.length; i++) {
2538      arrayAsList.add(
2539        filterValues[i]
2540      );
2541    }
2542    forAllUserDateTime0 (
2543      operator,
2544      arrayAsList
2545    );
2546  }
2547
2548  public void thereExistsUserDateTime0 (
2549    short operator,
2550    java.util.Date JavaDoc[] filterValues
2551  ) {
2552    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2553    for(int i = 0; i < filterValues.length; i++) {
2554      arrayAsList.add(
2555        filterValues[i]
2556      );
2557    }
2558    thereExistsUserDateTime0 (
2559      operator,
2560      arrayAsList
2561    );
2562  }
2563
2564  public void orderByUserDateTime0 (
2565    short order
2566  ) {
2567    refAddValue(
2568      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2569      order
2570    );
2571  }
2572      
2573// ----------------------------------------------------------------------------
2574
// Filter/ImplAttributeIsNotStruct
2575
// ----------------------------------------------------------------------------
2576
public void forAllUserDateTime1 (
2577    short operator,
2578    java.util.Collection JavaDoc values
2579  ) {
2580    refAddValue(
2581      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2582      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2583      operator,
2584      values
2585    );
2586  }
2587
2588  public void thereExistsUserDateTime1 (
2589    short operator,
2590    java.util.Collection JavaDoc values
2591  ) {
2592    refAddValue(
2593      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2594      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2595      operator,
2596      values
2597    );
2598  }
2599
2600  public void forAllUserDateTime1 (
2601    short operator,
2602    java.util.Date JavaDoc[] filterValues
2603  ) {
2604    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2605    for(int i = 0; i < filterValues.length; i++) {
2606      arrayAsList.add(
2607        filterValues[i]
2608      );
2609    }
2610    forAllUserDateTime1 (
2611      operator,
2612      arrayAsList
2613    );
2614  }
2615
2616  public void thereExistsUserDateTime1 (
2617    short operator,
2618    java.util.Date JavaDoc[] filterValues
2619  ) {
2620    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2621    for(int i = 0; i < filterValues.length; i++) {
2622      arrayAsList.add(
2623        filterValues[i]
2624      );
2625    }
2626    thereExistsUserDateTime1 (
2627      operator,
2628      arrayAsList
2629    );
2630  }
2631
2632  public void orderByUserDateTime1 (
2633    short order
2634  ) {
2635    refAddValue(
2636      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2637      order
2638    );
2639  }
2640      
2641// ----------------------------------------------------------------------------
2642
// Filter/ImplAttributeIsNotStruct
2643
// ----------------------------------------------------------------------------
2644
public void forAllUserDateTime2 (
2645    short operator,
2646    java.util.Collection JavaDoc values
2647  ) {
2648    refAddValue(
2649      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2650      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2651      operator,
2652      values
2653    );
2654  }
2655
2656  public void thereExistsUserDateTime2 (
2657    short operator,
2658    java.util.Collection JavaDoc values
2659  ) {
2660    refAddValue(
2661      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2662      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2663      operator,
2664      values
2665    );
2666  }
2667
2668  public void forAllUserDateTime2 (
2669    short operator,
2670    java.util.Date JavaDoc[] filterValues
2671  ) {
2672    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2673    for(int i = 0; i < filterValues.length; i++) {
2674      arrayAsList.add(
2675        filterValues[i]
2676      );
2677    }
2678    forAllUserDateTime2 (
2679      operator,
2680      arrayAsList
2681    );
2682  }
2683
2684  public void thereExistsUserDateTime2 (
2685    short operator,
2686    java.util.Date JavaDoc[] filterValues
2687  ) {
2688    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2689    for(int i = 0; i < filterValues.length; i++) {
2690      arrayAsList.add(
2691        filterValues[i]
2692      );
2693    }
2694    thereExistsUserDateTime2 (
2695      operator,
2696      arrayAsList
2697    );
2698  }
2699
2700  public void orderByUserDateTime2 (
2701    short order
2702  ) {
2703    refAddValue(
2704      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2705      order
2706    );
2707  }
2708      
2709// ----------------------------------------------------------------------------
2710
// Filter/ImplAttributeIsNotStruct
2711
// ----------------------------------------------------------------------------
2712
public void forAllUserDateTime3 (
2713    short operator,
2714    java.util.Collection JavaDoc values
2715  ) {
2716    refAddValue(
2717      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2718      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2719      operator,
2720      values
2721    );
2722  }
2723
2724  public void thereExistsUserDateTime3 (
2725    short operator,
2726    java.util.Collection JavaDoc values
2727  ) {
2728    refAddValue(
2729      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2730      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2731      operator,
2732      values
2733    );
2734  }
2735
2736  public void forAllUserDateTime3 (
2737    short operator,
2738    java.util.Date JavaDoc[] filterValues
2739  ) {
2740    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2741    for(int i = 0; i < filterValues.length; i++) {
2742      arrayAsList.add(
2743        filterValues[i]
2744      );
2745    }
2746    forAllUserDateTime3 (
2747      operator,
2748      arrayAsList
2749    );
2750  }
2751
2752  public void thereExistsUserDateTime3 (
2753    short operator,
2754    java.util.Date JavaDoc[] filterValues
2755  ) {
2756    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2757    for(int i = 0; i < filterValues.length; i++) {
2758      arrayAsList.add(
2759        filterValues[i]
2760      );
2761    }
2762    thereExistsUserDateTime3 (
2763      operator,
2764      arrayAsList
2765    );
2766  }
2767
2768  public void orderByUserDateTime3 (
2769    short order
2770  ) {
2771    refAddValue(
2772      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2773      order
2774    );
2775  }
2776      
2777// ----------------------------------------------------------------------------
2778
// Filter/ImplAttributeIsNotStruct
2779
// ----------------------------------------------------------------------------
2780
public void forAllUserDateTime4 (
2781    short operator,
2782    java.util.Collection JavaDoc values
2783  ) {
2784    refAddValue(
2785      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2786      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2787      operator,
2788      values
2789    );
2790  }
2791
2792  public void thereExistsUserDateTime4 (
2793    short operator,
2794    java.util.Collection JavaDoc values
2795  ) {
2796    refAddValue(
2797      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2798      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2799      operator,
2800      values
2801    );
2802  }
2803
2804  public void forAllUserDateTime4 (
2805    short operator,
2806    java.util.Date JavaDoc[] filterValues
2807  ) {
2808    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2809    for(int i = 0; i < filterValues.length; i++) {
2810      arrayAsList.add(
2811        filterValues[i]
2812      );
2813    }
2814    forAllUserDateTime4 (
2815      operator,
2816      arrayAsList
2817    );
2818  }
2819
2820  public void thereExistsUserDateTime4 (
2821    short operator,
2822    java.util.Date JavaDoc[] filterValues
2823  ) {
2824    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2825    for(int i = 0; i < filterValues.length; i++) {
2826      arrayAsList.add(
2827        filterValues[i]
2828      );
2829    }
2830    thereExistsUserDateTime4 (
2831      operator,
2832      arrayAsList
2833    );
2834  }
2835
2836  public void orderByUserDateTime4 (
2837    short order
2838  ) {
2839    refAddValue(
2840      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2841      order
2842    );
2843  }
2844      
2845// ----------------------------------------------------------------------------
2846
// Filter/ImplAttributeIsNotStruct
2847
// ----------------------------------------------------------------------------
2848
public void forAllUserNumber0 (
2849    short operator,
2850    java.util.Collection JavaDoc values
2851  ) {
2852    refAddValue(
2853      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2854      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2855      operator,
2856      values
2857    );
2858  }
2859
2860  public void thereExistsUserNumber0 (
2861    short operator,
2862    java.util.Collection JavaDoc values
2863  ) {
2864    refAddValue(
2865      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2866      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2867      operator,
2868      values
2869    );
2870  }
2871
2872  public void forAllUserNumber0 (
2873    short operator,
2874    java.math.BigDecimal JavaDoc[] filterValues
2875  ) {
2876    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2877    for(int i = 0; i < filterValues.length; i++) {
2878      arrayAsList.add(
2879        filterValues[i]
2880      );
2881    }
2882    forAllUserNumber0 (
2883      operator,
2884      arrayAsList
2885    );
2886  }
2887
2888  public void thereExistsUserNumber0 (
2889    short operator,
2890    java.math.BigDecimal JavaDoc[] filterValues
2891  ) {
2892    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2893    for(int i = 0; i < filterValues.length; i++) {
2894      arrayAsList.add(
2895        filterValues[i]
2896      );
2897    }
2898    thereExistsUserNumber0 (
2899      operator,
2900      arrayAsList
2901    );
2902  }
2903
2904  public void orderByUserNumber0 (
2905    short order
2906  ) {
2907    refAddValue(
2908      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2909      order
2910    );
2911  }
2912      
2913// ----------------------------------------------------------------------------
2914
// Filter/ImplAttributeIsNotStruct
2915
// ----------------------------------------------------------------------------
2916
public void forAllUserNumber1 (
2917    short operator,
2918    java.util.Collection JavaDoc values
2919  ) {
2920    refAddValue(
2921      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2922      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2923      operator,
2924      values
2925    );
2926  }
2927
2928  public void thereExistsUserNumber1 (
2929    short operator,
2930    java.util.Collection JavaDoc values
2931  ) {
2932    refAddValue(
2933      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2934      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2935      operator,
2936      values
2937    );
2938  }
2939
2940  public void forAllUserNumber1 (
2941    short operator,
2942    java.math.BigDecimal JavaDoc[] filterValues
2943  ) {
2944    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2945    for(int i = 0; i < filterValues.length; i++) {
2946      arrayAsList.add(
2947        filterValues[i]
2948      );
2949    }
2950    forAllUserNumber1 (
2951      operator,
2952      arrayAsList
2953    );
2954  }
2955
2956  public void thereExistsUserNumber1 (
2957    short operator,
2958    java.math.BigDecimal JavaDoc[] filterValues
2959  ) {
2960    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2961    for(int i = 0; i < filterValues.length; i++) {
2962      arrayAsList.add(
2963        filterValues[i]
2964      );
2965    }
2966    thereExistsUserNumber1 (
2967      operator,
2968      arrayAsList
2969    );
2970  }
2971
2972  public void orderByUserNumber1 (
2973    short order
2974  ) {
2975    refAddValue(
2976      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2977      order
2978    );
2979  }
2980      
2981// ----------------------------------------------------------------------------
2982
// Filter/ImplAttributeIsNotStruct
2983
// ----------------------------------------------------------------------------
2984
public void forAllUserNumber2 (
2985    short operator,
2986    java.util.Collection JavaDoc values
2987  ) {
2988    refAddValue(
2989      "org:opencrx:kernel:generic:CrxObject:userNumber2",
2990      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2991      operator,
2992      values
2993    );
2994  }
2995
2996  public void thereExistsUserNumber2 (
2997    short operator,
2998    java.util.Collection JavaDoc values
2999  ) {
3000    refAddValue(
3001      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3002      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3003      operator,
3004      values
3005    );
3006  }
3007
3008  public void forAllUserNumber2 (
3009    short operator,
3010    java.math.BigDecimal JavaDoc[] filterValues
3011  ) {
3012    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3013    for(int i = 0; i < filterValues.length; i++) {
3014      arrayAsList.add(
3015        filterValues[i]
3016      );
3017    }
3018    forAllUserNumber2 (
3019      operator,
3020      arrayAsList
3021    );
3022  }
3023
3024  public void thereExistsUserNumber2 (
3025    short operator,
3026    java.math.BigDecimal JavaDoc[] filterValues
3027  ) {
3028    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3029    for(int i = 0; i < filterValues.length; i++) {
3030      arrayAsList.add(
3031        filterValues[i]
3032      );
3033    }
3034    thereExistsUserNumber2 (
3035      operator,
3036      arrayAsList
3037    );
3038  }
3039
3040  public void orderByUserNumber2 (
3041    short order
3042  ) {
3043    refAddValue(
3044      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3045      order
3046    );
3047  }
3048      
3049// ----------------------------------------------------------------------------
3050
// Filter/ImplAttributeIsNotStruct
3051
// ----------------------------------------------------------------------------
3052
public void forAllUserNumber3 (
3053    short operator,
3054    java.util.Collection JavaDoc values
3055  ) {
3056    refAddValue(
3057      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3058      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3059      operator,
3060      values
3061    );
3062  }
3063
3064  public void thereExistsUserNumber3 (
3065    short operator,
3066    java.util.Collection JavaDoc values
3067  ) {
3068    refAddValue(
3069      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3070      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3071      operator,
3072      values
3073    );
3074  }
3075
3076  public void forAllUserNumber3 (
3077    short operator,
3078    java.math.BigDecimal JavaDoc[] filterValues
3079  ) {
3080    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3081    for(int i = 0; i < filterValues.length; i++) {
3082      arrayAsList.add(
3083        filterValues[i]
3084      );
3085    }
3086    forAllUserNumber3 (
3087      operator,
3088      arrayAsList
3089    );
3090  }
3091
3092  public void thereExistsUserNumber3 (
3093    short operator,
3094    java.math.BigDecimal JavaDoc[] filterValues
3095  ) {
3096    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3097    for(int i = 0; i < filterValues.length; i++) {
3098      arrayAsList.add(
3099        filterValues[i]
3100      );
3101    }
3102    thereExistsUserNumber3 (
3103      operator,
3104      arrayAsList
3105    );
3106  }
3107
3108  public void orderByUserNumber3 (
3109    short order
3110  ) {
3111    refAddValue(
3112      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3113      order
3114    );
3115  }
3116      
3117// ----------------------------------------------------------------------------
3118
// Filter/ImplAttributeIsNotStruct
3119
// ----------------------------------------------------------------------------
3120
public void forAllUserNumber4 (
3121    short operator,
3122    java.util.Collection JavaDoc values
3123  ) {
3124    refAddValue(
3125      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3126      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3127      operator,
3128      values
3129    );
3130  }
3131
3132  public void thereExistsUserNumber4 (
3133    short operator,
3134    java.util.Collection JavaDoc values
3135  ) {
3136    refAddValue(
3137      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3138      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3139      operator,
3140      values
3141    );
3142  }
3143
3144  public void forAllUserNumber4 (
3145    short operator,
3146    java.math.BigDecimal JavaDoc[] filterValues
3147  ) {
3148    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3149    for(int i = 0; i < filterValues.length; i++) {
3150      arrayAsList.add(
3151        filterValues[i]
3152      );
3153    }
3154    forAllUserNumber4 (
3155      operator,
3156      arrayAsList
3157    );
3158  }
3159
3160  public void thereExistsUserNumber4 (
3161    short operator,
3162    java.math.BigDecimal JavaDoc[] filterValues
3163  ) {
3164    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3165    for(int i = 0; i < filterValues.length; i++) {
3166      arrayAsList.add(
3167        filterValues[i]
3168      );
3169    }
3170    thereExistsUserNumber4 (
3171      operator,
3172      arrayAsList
3173    );
3174  }
3175
3176  public void orderByUserNumber4 (
3177    short order
3178  ) {
3179    refAddValue(
3180      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3181      order
3182    );
3183  }
3184      
3185// ----------------------------------------------------------------------------
3186
// Filter/ImplAttributeIsNotStruct
3187
// ----------------------------------------------------------------------------
3188
public void forAllUserString0 (
3189    short operator,
3190    java.util.Collection JavaDoc values
3191  ) {
3192    refAddValue(
3193      "org:opencrx:kernel:generic:CrxObject:userString0",
3194      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3195      operator,
3196      values
3197    );
3198  }
3199
3200  public void thereExistsUserString0 (
3201    short operator,
3202    java.util.Collection JavaDoc values
3203  ) {
3204    refAddValue(
3205      "org:opencrx:kernel:generic:CrxObject:userString0",
3206      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3207      operator,
3208      values
3209    );
3210  }
3211
3212  public void forAllUserString0 (
3213    short operator,
3214    String JavaDoc[] filterValues
3215  ) {
3216    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3217    for(int i = 0; i < filterValues.length; i++) {
3218      arrayAsList.add(
3219        filterValues[i]
3220      );
3221    }
3222    forAllUserString0 (
3223      operator,
3224      arrayAsList
3225    );
3226  }
3227
3228  public void thereExistsUserString0 (
3229    short operator,
3230    String JavaDoc[] filterValues
3231  ) {
3232    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3233    for(int i = 0; i < filterValues.length; i++) {
3234      arrayAsList.add(
3235        filterValues[i]
3236      );
3237    }
3238    thereExistsUserString0 (
3239      operator,
3240      arrayAsList
3241    );
3242  }
3243
3244  public void orderByUserString0 (
3245    short order
3246  ) {
3247    refAddValue(
3248      "org:opencrx:kernel:generic:CrxObject:userString0",
3249      order
3250    );
3251  }
3252      
3253// ----------------------------------------------------------------------------
3254
// Filter/ImplAttributeIsNotStruct
3255
// ----------------------------------------------------------------------------
3256
public void forAllUserString1 (
3257    short operator,
3258    java.util.Collection JavaDoc values
3259  ) {
3260    refAddValue(
3261      "org:opencrx:kernel:generic:CrxObject:userString1",
3262      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3263      operator,
3264      values
3265    );
3266  }
3267
3268  public void thereExistsUserString1 (
3269    short operator,
3270    java.util.Collection JavaDoc values
3271  ) {
3272    refAddValue(
3273      "org:opencrx:kernel:generic:CrxObject:userString1",
3274      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3275      operator,
3276      values
3277    );
3278  }
3279
3280  public void forAllUserString1 (
3281    short operator,
3282    String JavaDoc[] filterValues
3283  ) {
3284    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3285    for(int i = 0; i < filterValues.length; i++) {
3286      arrayAsList.add(
3287        filterValues[i]
3288      );
3289    }
3290    forAllUserString1 (
3291      operator,
3292      arrayAsList
3293    );
3294  }
3295
3296  public void thereExistsUserString1 (
3297    short operator,
3298    String JavaDoc[] filterValues
3299  ) {
3300    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3301    for(int i = 0; i < filterValues.length; i++) {
3302      arrayAsList.add(
3303        filterValues[i]
3304      );
3305    }
3306    thereExistsUserString1 (
3307      operator,
3308      arrayAsList
3309    );
3310  }
3311
3312  public void orderByUserString1 (
3313    short order
3314  ) {
3315    refAddValue(
3316      "org:opencrx:kernel:generic:CrxObject:userString1",
3317      order
3318    );
3319  }
3320      
3321// ----------------------------------------------------------------------------
3322
// Filter/ImplAttributeIsNotStruct
3323
// ----------------------------------------------------------------------------
3324
public void forAllUserString2 (
3325    short operator,
3326    java.util.Collection JavaDoc values
3327  ) {
3328    refAddValue(
3329      "org:opencrx:kernel:generic:CrxObject:userString2",
3330      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3331      operator,
3332      values
3333    );
3334  }
3335
3336  public void thereExistsUserString2 (
3337    short operator,
3338    java.util.Collection JavaDoc values
3339  ) {
3340    refAddValue(
3341      "org:opencrx:kernel:generic:CrxObject:userString2",
3342      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3343      operator,
3344      values
3345    );
3346  }
3347
3348  public void forAllUserString2 (
3349    short operator,
3350    String JavaDoc[] filterValues
3351  ) {
3352    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3353    for(int i = 0; i < filterValues.length; i++) {
3354      arrayAsList.add(
3355        filterValues[i]
3356      );
3357    }
3358    forAllUserString2 (
3359      operator,
3360      arrayAsList
3361    );
3362  }
3363
3364  public void thereExistsUserString2 (
3365    short operator,
3366    String JavaDoc[] filterValues
3367  ) {
3368    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3369    for(int i = 0; i < filterValues.length; i++) {
3370      arrayAsList.add(
3371        filterValues[i]
3372      );
3373    }
3374    thereExistsUserString2 (
3375      operator,
3376      arrayAsList
3377    );
3378  }
3379
3380  public void orderByUserString2 (
3381    short order
3382  ) {
3383    refAddValue(
3384      "org:opencrx:kernel:generic:CrxObject:userString2",
3385      order
3386    );
3387  }
3388      
3389// ----------------------------------------------------------------------------
3390
// Filter/ImplAttributeIsNotStruct
3391
// ----------------------------------------------------------------------------
3392
public void forAllUserString3 (
3393    short operator,
3394    java.util.Collection JavaDoc values
3395  ) {
3396    refAddValue(
3397      "org:opencrx:kernel:generic:CrxObject:userString3",
3398      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3399      operator,
3400      values
3401    );
3402  }
3403
3404  public void thereExistsUserString3 (
3405    short operator,
3406    java.util.Collection JavaDoc values
3407  ) {
3408    refAddValue(
3409      "org:opencrx:kernel:generic:CrxObject:userString3",
3410      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3411      operator,
3412      values
3413    );
3414  }
3415
3416  public void forAllUserString3 (
3417    short operator,
3418    String JavaDoc[] filterValues
3419  ) {
3420    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3421    for(int i = 0; i < filterValues.length; i++) {
3422      arrayAsList.add(
3423        filterValues[i]
3424      );
3425    }
3426    forAllUserString3 (
3427      operator,
3428      arrayAsList
3429    );
3430  }
3431
3432  public void thereExistsUserString3 (
3433    short operator,
3434    String JavaDoc[] filterValues
3435  ) {
3436    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3437    for(int i = 0; i < filterValues.length; i++) {
3438      arrayAsList.add(
3439        filterValues[i]
3440      );
3441    }
3442    thereExistsUserString3 (
3443      operator,
3444      arrayAsList
3445    );
3446  }
3447
3448  public void orderByUserString3 (
3449    short order
3450  ) {
3451    refAddValue(
3452      "org:opencrx:kernel:generic:CrxObject:userString3",
3453      order
3454    );
3455  }
3456      
3457// ----------------------------------------------------------------------------
3458
// Filter/ImplAttributeIsNotStruct
3459
// ----------------------------------------------------------------------------
3460
public void forAllUserString4 (
3461    short operator,
3462    java.util.Collection JavaDoc values
3463  ) {
3464    refAddValue(
3465      "org:opencrx:kernel:generic:CrxObject:userString4",
3466      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3467      operator,
3468      values
3469    );
3470  }
3471
3472  public void thereExistsUserString4 (
3473    short operator,
3474    java.util.Collection JavaDoc values
3475  ) {
3476    refAddValue(
3477      "org:opencrx:kernel:generic:CrxObject:userString4",
3478      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3479      operator,
3480      values
3481    );
3482  }
3483
3484  public void forAllUserString4 (
3485    short operator,
3486    String JavaDoc[] filterValues
3487  ) {
3488    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3489    for(int i = 0; i < filterValues.length; i++) {
3490      arrayAsList.add(
3491        filterValues[i]
3492      );
3493    }
3494    forAllUserString4 (
3495      operator,
3496      arrayAsList
3497    );
3498  }
3499
3500  public void thereExistsUserString4 (
3501    short operator,
3502    String JavaDoc[] filterValues
3503  ) {
3504    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3505    for(int i = 0; i < filterValues.length; i++) {
3506      arrayAsList.add(
3507        filterValues[i]
3508      );
3509    }
3510    thereExistsUserString4 (
3511      operator,
3512      arrayAsList
3513    );
3514  }
3515
3516  public void orderByUserString4 (
3517    short order
3518  ) {
3519    refAddValue(
3520      "org:opencrx:kernel:generic:CrxObject:userString4",
3521      order
3522    );
3523  }
3524      
3525// ----------------------------------------------------------------------------
3526
// Filter/ImplAttributeIsNotStruct
3527
// ----------------------------------------------------------------------------
3528
public void forAllCreatedAt (
3529    short operator,
3530    java.util.Collection JavaDoc values
3531  ) {
3532    refAddValue(
3533      "org:openmdx:base:BasicObject:createdAt",
3534      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3535      operator,
3536      values
3537    );
3538  }
3539
3540  public void thereExistsCreatedAt (
3541    short operator,
3542    java.util.Collection JavaDoc values
3543  ) {
3544    refAddValue(
3545      "org:openmdx:base:BasicObject:createdAt",
3546      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3547      operator,
3548      values
3549    );
3550  }
3551
3552  public void forAllCreatedAt (
3553    short operator,
3554    java.util.Date JavaDoc[] filterValues
3555  ) {
3556    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3557    for(int i = 0; i < filterValues.length; i++) {
3558      arrayAsList.add(
3559        filterValues[i]
3560      );
3561    }
3562    forAllCreatedAt (
3563      operator,
3564      arrayAsList
3565    );
3566  }
3567
3568  public void thereExistsCreatedAt (
3569    short operator,
3570    java.util.Date JavaDoc[] filterValues
3571  ) {
3572    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3573    for(int i = 0; i < filterValues.length; i++) {
3574      arrayAsList.add(
3575        filterValues[i]
3576      );
3577    }
3578    thereExistsCreatedAt (
3579      operator,
3580      arrayAsList
3581    );
3582  }
3583
3584  public void orderByCreatedAt (
3585    short order
3586  ) {
3587    refAddValue(
3588      "org:openmdx:base:BasicObject:createdAt",
3589      order
3590    );
3591  }
3592      
3593// ----------------------------------------------------------------------------
3594
// Filter/ImplAttributeIsNotStruct
3595
// ----------------------------------------------------------------------------
3596
public void forAllCreatedBy (
3597    short operator,
3598    java.util.Collection JavaDoc values
3599  ) {
3600    refAddValue(
3601      "org:openmdx:base:BasicObject:createdBy",
3602      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3603      operator,
3604      values
3605    );
3606  }
3607
3608  public void thereExistsCreatedBy (
3609    short operator,
3610    java.util.Collection JavaDoc values
3611  ) {
3612    refAddValue(
3613      "org:openmdx:base:BasicObject:createdBy",
3614      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3615      operator,
3616      values
3617    );
3618  }
3619
3620  public void forAllCreatedBy (
3621    short operator,
3622    String JavaDoc[] filterValues
3623  ) {
3624    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3625    for(int i = 0; i < filterValues.length; i++) {
3626      arrayAsList.add(
3627        filterValues[i]
3628      );
3629    }
3630    forAllCreatedBy (
3631      operator,
3632      arrayAsList
3633    );
3634  }
3635
3636  public void thereExistsCreatedBy (
3637    short operator,
3638    String JavaDoc[] filterValues
3639  ) {
3640    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3641    for(int i = 0; i < filterValues.length; i++) {
3642      arrayAsList.add(
3643        filterValues[i]
3644      );
3645    }
3646    thereExistsCreatedBy (
3647      operator,
3648      arrayAsList
3649    );
3650  }
3651
3652  public void orderByCreatedBy (
3653    short order
3654  ) {
3655    refAddValue(
3656      "org:openmdx:base:BasicObject:createdBy",
3657      order
3658    );
3659  }
3660      
3661// ----------------------------------------------------------------------------
3662
// Filter/ImplAttributeIsNotStruct
3663
// ----------------------------------------------------------------------------
3664
public void forAllModifiedAt (
3665    short operator,
3666    java.util.Collection JavaDoc values
3667  ) {
3668    refAddValue(
3669      "org:openmdx:base:BasicObject:modifiedAt",
3670      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3671      operator,
3672      values
3673    );
3674  }
3675
3676  public void thereExistsModifiedAt (
3677    short operator,
3678    java.util.Collection JavaDoc values
3679  ) {
3680    refAddValue(
3681      "org:openmdx:base:BasicObject:modifiedAt",
3682      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3683      operator,
3684      values
3685    );
3686  }
3687
3688  public void forAllModifiedAt (
3689    short operator,
3690    java.util.Date JavaDoc[] filterValues
3691  ) {
3692    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3693    for(int i = 0; i < filterValues.length; i++) {
3694      arrayAsList.add(
3695        filterValues[i]
3696      );
3697    }
3698    forAllModifiedAt (
3699      operator,
3700      arrayAsList
3701    );
3702  }
3703
3704  public void thereExistsModifiedAt (
3705    short operator,
3706    java.util.Date JavaDoc[] filterValues
3707  ) {
3708    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3709    for(int i = 0; i < filterValues.length; i++) {
3710      arrayAsList.add(
3711        filterValues[i]
3712      );
3713    }
3714    thereExistsModifiedAt (
3715      operator,
3716      arrayAsList
3717    );
3718  }
3719
3720  public void orderByModifiedAt (
3721    short order
3722  ) {
3723    refAddValue(
3724      "org:openmdx:base:BasicObject:modifiedAt",
3725      order
3726    );
3727  }
3728      
3729// ----------------------------------------------------------------------------
3730
// Filter/ImplAttributeIsNotStruct
3731
// ----------------------------------------------------------------------------
3732
public void forAllModifiedBy (
3733    short operator,
3734    java.util.Collection JavaDoc values
3735  ) {
3736    refAddValue(
3737      "org:openmdx:base:BasicObject:modifiedBy",
3738      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3739      operator,
3740      values
3741    );
3742  }
3743
3744  public void thereExistsModifiedBy (
3745    short operator,
3746    java.util.Collection JavaDoc values
3747  ) {
3748    refAddValue(
3749      "org:openmdx:base:BasicObject:modifiedBy",
3750      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3751      operator,
3752      values
3753    );
3754  }
3755
3756  public void forAllModifiedBy (
3757    short operator,
3758    String JavaDoc[] filterValues
3759  ) {
3760    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3761    for(int i = 0; i < filterValues.length; i++) {
3762      arrayAsList.add(
3763        filterValues[i]
3764      );
3765    }
3766    forAllModifiedBy (
3767      operator,
3768      arrayAsList
3769    );
3770  }
3771
3772  public void thereExistsModifiedBy (
3773    short operator,
3774    String JavaDoc[] filterValues
3775  ) {
3776    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3777    for(int i = 0; i < filterValues.length; i++) {
3778      arrayAsList.add(
3779        filterValues[i]
3780      );
3781    }
3782    thereExistsModifiedBy (
3783      operator,
3784      arrayAsList
3785    );
3786  }
3787
3788  public void orderByModifiedBy (
3789    short order
3790  ) {
3791    refAddValue(
3792      "org:openmdx:base:BasicObject:modifiedBy",
3793      order
3794    );
3795  }
3796      
3797// ----------------------------------------------------------------------------
3798
// Filter/ImplReference
3799
// ----------------------------------------------------------------------------
3800
public void forAllContext (
3801    short operator,
3802    org.openmdx.base.cci.Context[] filterValues
3803  ) {
3804    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3805    for(int i = 0; i < filterValues.length; i++) {
3806      arrayAsList.add(
3807        filterValues[i]
3808      );
3809    }
3810    forAllContext (
3811      operator,
3812      arrayAsList
3813    );
3814  }
3815
3816  public void thereExistsContext (
3817    short operator,
3818    org.openmdx.base.cci.Context[] filterValues
3819  ) {
3820    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3821    for(int i = 0; i < filterValues.length; i++) {
3822      arrayAsList.add(
3823        filterValues[i]
3824      );
3825    }
3826    thereExistsContext (
3827      operator,
3828      arrayAsList
3829    );
3830  }
3831
3832  public void forAllContext (
3833    short operator,
3834    java.util.Collection JavaDoc values
3835  ) {
3836    refAddValue(
3837      "org:openmdx:base:ContextCapable:context",
3838      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3839      operator,
3840      values
3841    );
3842  }
3843
3844  public void thereExistsContext (
3845    short operator,
3846    java.util.Collection JavaDoc values
3847  ) {
3848    refAddValue(
3849      "org:openmdx:base:ContextCapable:context",
3850      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3851      operator,
3852      values
3853    );
3854  }
3855      
3856// ----------------------------------------------------------------------------
3857
// Filter/ImplAttributeIsNotStruct
3858
// ----------------------------------------------------------------------------
3859
public void forAllIdentity (
3860    short operator,
3861    java.util.Collection JavaDoc values
3862  ) {
3863    refAddValue(
3864      "org:openmdx:base:ExtentCapable:identity",
3865      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3866      operator,
3867      values
3868    );
3869  }
3870
3871  public void thereExistsIdentity (
3872    short operator,
3873    java.util.Collection JavaDoc values
3874  ) {
3875    refAddValue(
3876      "org:openmdx:base:ExtentCapable:identity",
3877      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3878      operator,
3879      values
3880    );
3881  }
3882
3883  public void forAllIdentity (
3884    short operator,
3885    String JavaDoc[] filterValues
3886  ) {
3887    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3888    for(int i = 0; i < filterValues.length; i++) {
3889      arrayAsList.add(
3890        filterValues[i]
3891      );
3892    }
3893    forAllIdentity (
3894      operator,
3895      arrayAsList
3896    );
3897  }
3898
3899  public void thereExistsIdentity (
3900    short operator,
3901    String JavaDoc[] filterValues
3902  ) {
3903    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
3904    for(int i = 0; i < filterValues.length; i++) {
3905      arrayAsList.add(
3906        filterValues[i]
3907      );
3908    }
3909    thereExistsIdentity (
3910      operator,
3911      arrayAsList
3912    );
3913  }
3914
3915  public void orderByIdentity (
3916    short order
3917  ) {
3918    refAddValue(
3919      "org:openmdx:base:ExtentCapable:identity",
3920      order
3921    );
3922  }
3923      
3924// ----------------------------------------------------------------------------
3925
// Filter/ImplEnd
3926
// ----------------------------------------------------------------------------
3927
}
3928
Popular Tags