CompoundBookingFilterImpl


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