KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencrx > kernel > model1 > cci > OperationFilterImpl


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