CreditBookingFilterImpl


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