KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencrx > kernel > contract1 > cci > AccountAddressFilterImpl


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