ActivityTrackerFilterImpl


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