TaskFilterImpl


1   // ----------------------------------------------------------------------------
2   // Filter/ImplBegin
3   // ----------------------------------------------------------------------------
4   //////////////////////////////////////////////////////////////////////////////
5   //
6   // Name: $Id: JMIAbstractMapper.java,v 1.11 2006/01/21 23:09:07 wfro Exp $
7   // Generated by: openMDX JMI Mapper
8   // Date: Mon Apr 03 11:39:03 CEST 2006
9   //
10  // GENERATED - DO NOT CHANGE MANUALLY
11  //
12  //////////////////////////////////////////////////////////////////////////////
13  package org.opencrx.kernel.activity1.cci;
14  
15  public class TaskFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements TaskFilter {
18  
19    public TaskFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:activity1:Task",
25        null,
26        null
27      );
28    }
29  
30    public TaskFilterImpl(
31      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage,
32      org.openmdx.compatibility.base.query.FilterProperty[] filterProperties,
33      org.openmdx.compatibility.base.dataprovider.cci.AttributeSpecifier[] attributeSpecifiers
34    ) {
35      super(
36        aPackage,
37        "org:opencrx:kernel:activity1:Task",
38        filterProperties,
39        attributeSpecifiers
40      );
41    }
42        
43  // ----------------------------------------------------------------------------
44  // Filter/ImplAttributeIsNotStruct
45  // ----------------------------------------------------------------------------
46    public void forAllActivityNumber (
47      short operator,
48      java.util.Collection   values
49    ) {
50      refAddValue(
51        "org:opencrx:kernel:activity1:Activity:activityNumber",
52        org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53        operator,
54        values
55      );
56    }
57  
58    public void thereExistsActivityNumber (
59      short operator,
60      java.util.Collection   values
61    ) {
62      refAddValue(
63        "org:opencrx:kernel:activity1:Activity:activityNumber",
64        org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65        operator,
66        values
67      );
68    }
69  
70    public void forAllActivityNumber (
71      short operator,
72      String  [] filterValues
73    ) {
74      java.util.List   arrayAsList = new java.util.ArrayList  ();
75      for(int i = 0; i < filterValues.length; i++) {
76        arrayAsList.add(
77          filterValues[i]
78        );
79      }
80      forAllActivityNumber (
81        operator,
82        arrayAsList
83      );
84    }
85  
86    public void thereExistsActivityNumber (
87      short operator,
88      String  [] filterValues
89    ) {
90      java.util.List   arrayAsList = new java.util.ArrayList  ();
91      for(int i = 0; i < filterValues.length; i++) {
92        arrayAsList.add(
93          filterValues[i]
94        );
95      }
96      thereExistsActivityNumber (
97        operator,
98        arrayAsList
99      );
100   }
101 
102   public void orderByActivityNumber (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:activity1:Activity:activityNumber",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112 // Filter/ImplAttributeIsNotStruct
113 // ----------------------------------------------------------------------------
114   public void forAllActivityState (
115     short operator,
116     java.util.Collection   values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:activity1:Activity:activityState",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125 
126   public void thereExistsActivityState (
127     short operator,
128     java.util.Collection   values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:activity1:Activity:activityState",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137 
138   public void forAllActivityState (
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     forAllActivityState (
149       operator,
150       arrayAsList
151     );
152   }
153 
154   public void thereExistsActivityState (
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     thereExistsActivityState (
165       operator,
166       arrayAsList
167     );
168   }
169 
170   public void orderByActivityState (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:activity1:Activity:activityState",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180 // Filter/ImplReference
181 // ----------------------------------------------------------------------------
182   public void forAllActivityType (
183     short operator,
184     org.opencrx.kernel.activity1.cci.ActivityType[] filterValues
185   ) {
186     java.util.List   arrayAsList = new java.util.ArrayList  ();
187     for(int i = 0; i < filterValues.length; i++) {
188       arrayAsList.add(
189         filterValues[i]
190       );
191     }
192     forAllActivityType (
193       operator,
194       arrayAsList
195     );
196   }
197 
198   public void thereExistsActivityType (
199     short operator,
200     org.opencrx.kernel.activity1.cci.ActivityType[] filterValues
201   ) {
202     java.util.List   arrayAsList = new java.util.ArrayList  ();
203     for(int i = 0; i < filterValues.length; i++) {
204       arrayAsList.add(
205         filterValues[i]
206       );
207     }
208     thereExistsActivityType (
209       operator,
210       arrayAsList
211     );
212   }
213 
214   public void forAllActivityType (
215     short operator,
216     java.util.Collection   values
217   ) {
218     refAddValue(
219       "org:opencrx:kernel:activity1:Activity:activityType",
220       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
221       operator,
222       values
223     );
224   }
225 
226   public void thereExistsActivityType (
227     short operator,
228     java.util.Collection   values
229   ) {
230     refAddValue(
231       "org:opencrx:kernel:activity1:Activity:activityType",
232       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
233       operator,
234       values
235     );
236   }
237       
238 // ----------------------------------------------------------------------------
239 // Filter/ImplAttributeIsNotStruct
240 // ----------------------------------------------------------------------------
241   public void forAllActualEffortHours (
242     short operator,
243     java.util.Collection   values
244   ) {
245     refAddValue(
246       "org:opencrx:kernel:activity1:Activity:actualEffortHours",
247       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
248       operator,
249       values
250     );
251   }
252 
253   public void thereExistsActualEffortHours (
254     short operator,
255     java.util.Collection   values
256   ) {
257     refAddValue(
258       "org:opencrx:kernel:activity1:Activity:actualEffortHours",
259       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
260       operator,
261       values
262     );
263   }
264 
265   public void forAllActualEffortHours (
266     short operator,
267     int[] filterValues
268   ) {
269     java.util.List   arrayAsList = new java.util.ArrayList  ();
270     for(int i = 0; i < filterValues.length; i++) {
271       arrayAsList.add(
272         new Integer  (filterValues[i])
273       );
274     }
275     forAllActualEffortHours (
276       operator,
277       arrayAsList
278     );
279   }
280 
281   public void thereExistsActualEffortHours (
282     short operator,
283     int[] filterValues
284   ) {
285     java.util.List   arrayAsList = new java.util.ArrayList  ();
286     for(int i = 0; i < filterValues.length; i++) {
287       arrayAsList.add(
288         new Integer  (filterValues[i])
289       );
290     }
291     thereExistsActualEffortHours (
292       operator,
293       arrayAsList
294     );
295   }
296 
297   public void orderByActualEffortHours (
298     short order
299   ) {
300     refAddValue(
301       "org:opencrx:kernel:activity1:Activity:actualEffortHours",
302       order
303     );
304   }
305       
306 // ----------------------------------------------------------------------------
307 // Filter/ImplAttributeIsNotStruct
308 // ----------------------------------------------------------------------------
309   public void forAllActualEffortMinutes (
310     short operator,
311     java.util.Collection   values
312   ) {
313     refAddValue(
314       "org:opencrx:kernel:activity1:Activity:actualEffortMinutes",
315       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
316       operator,
317       values
318     );
319   }
320 
321   public void thereExistsActualEffortMinutes (
322     short operator,
323     java.util.Collection   values
324   ) {
325     refAddValue(
326       "org:opencrx:kernel:activity1:Activity:actualEffortMinutes",
327       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
328       operator,
329       values
330     );
331   }
332 
333   public void forAllActualEffortMinutes (
334     short operator,
335     int[] filterValues
336   ) {
337     java.util.List   arrayAsList = new java.util.ArrayList  ();
338     for(int i = 0; i < filterValues.length; i++) {
339       arrayAsList.add(
340         new Integer  (filterValues[i])
341       );
342     }
343     forAllActualEffortMinutes (
344       operator,
345       arrayAsList
346     );
347   }
348 
349   public void thereExistsActualEffortMinutes (
350     short operator,
351     int[] filterValues
352   ) {
353     java.util.List   arrayAsList = new java.util.ArrayList  ();
354     for(int i = 0; i < filterValues.length; i++) {
355       arrayAsList.add(
356         new Integer  (filterValues[i])
357       );
358     }
359     thereExistsActualEffortMinutes (
360       operator,
361       arrayAsList
362     );
363   }
364 
365   public void orderByActualEffortMinutes (
366     short order
367   ) {
368     refAddValue(
369       "org:opencrx:kernel:activity1:Activity:actualEffortMinutes",
370       order
371     );
372   }
373       
374 // ----------------------------------------------------------------------------
375 // Filter/ImplAttributeIsNotStruct
376 // ----------------------------------------------------------------------------
377   public void forAllActualEnd (
378     short operator,
379     java.util.Collection   values
380   ) {
381     refAddValue(
382       "org:opencrx:kernel:activity1:Activity:actualEnd",
383       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
384       operator,
385       values
386     );
387   }
388 
389   public void thereExistsActualEnd (
390     short operator,
391     java.util.Collection   values
392   ) {
393     refAddValue(
394       "org:opencrx:kernel:activity1:Activity:actualEnd",
395       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
396       operator,
397       values
398     );
399   }
400 
401   public void forAllActualEnd (
402     short operator,
403     java.util.Date  [] filterValues
404   ) {
405     java.util.List   arrayAsList = new java.util.ArrayList  ();
406     for(int i = 0; i < filterValues.length; i++) {
407       arrayAsList.add(
408         filterValues[i]
409       );
410     }
411     forAllActualEnd (
412       operator,
413       arrayAsList
414     );
415   }
416 
417   public void thereExistsActualEnd (
418     short operator,
419     java.util.Date  [] filterValues
420   ) {
421     java.util.List   arrayAsList = new java.util.ArrayList  ();
422     for(int i = 0; i < filterValues.length; i++) {
423       arrayAsList.add(
424         filterValues[i]
425       );
426     }
427     thereExistsActualEnd (
428       operator,
429       arrayAsList
430     );
431   }
432 
433   public void orderByActualEnd (
434     short order
435   ) {
436     refAddValue(
437       "org:opencrx:kernel:activity1:Activity:actualEnd",
438       order
439     );
440   }
441       
442 // ----------------------------------------------------------------------------
443 // Filter/ImplAttributeIsNotStruct
444 // ----------------------------------------------------------------------------
445   public void forAllActualStart (
446     short operator,
447     java.util.Collection   values
448   ) {
449     refAddValue(
450       "org:opencrx:kernel:activity1:Activity:actualStart",
451       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
452       operator,
453       values
454     );
455   }
456 
457   public void thereExistsActualStart (
458     short operator,
459     java.util.Collection   values
460   ) {
461     refAddValue(
462       "org:opencrx:kernel:activity1:Activity:actualStart",
463       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
464       operator,
465       values
466     );
467   }
468 
469   public void forAllActualStart (
470     short operator,
471     java.util.Date  [] filterValues
472   ) {
473     java.util.List   arrayAsList = new java.util.ArrayList  ();
474     for(int i = 0; i < filterValues.length; i++) {
475       arrayAsList.add(
476         filterValues[i]
477       );
478     }
479     forAllActualStart (
480       operator,
481       arrayAsList
482     );
483   }
484 
485   public void thereExistsActualStart (
486     short operator,
487     java.util.Date  [] filterValues
488   ) {
489     java.util.List   arrayAsList = new java.util.ArrayList  ();
490     for(int i = 0; i < filterValues.length; i++) {
491       arrayAsList.add(
492         filterValues[i]
493       );
494     }
495     thereExistsActualStart (
496       operator,
497       arrayAsList
498     );
499   }
500 
501   public void orderByActualStart (
502     short order
503   ) {
504     refAddValue(
505       "org:opencrx:kernel:activity1:Activity:actualStart",
506       order
507     );
508   }
509       
510 // ----------------------------------------------------------------------------
511 // Filter/ImplReference
512 // ----------------------------------------------------------------------------
513   public void forAllAssignedTo (
514     short operator,
515     org.opencrx.kernel.account1.cci.Contact[] filterValues
516   ) {
517     java.util.List   arrayAsList = new java.util.ArrayList  ();
518     for(int i = 0; i < filterValues.length; i++) {
519       arrayAsList.add(
520         filterValues[i]
521       );
522     }
523     forAllAssignedTo (
524       operator,
525       arrayAsList
526     );
527   }
528 
529   public void thereExistsAssignedTo (
530     short operator,
531     org.opencrx.kernel.account1.cci.Contact[] filterValues
532   ) {
533     java.util.List   arrayAsList = new java.util.ArrayList  ();
534     for(int i = 0; i < filterValues.length; i++) {
535       arrayAsList.add(
536         filterValues[i]
537       );
538     }
539     thereExistsAssignedTo (
540       operator,
541       arrayAsList
542     );
543   }
544 
545   public void forAllAssignedTo (
546     short operator,
547     java.util.Collection   values
548   ) {
549     refAddValue(
550       "org:opencrx:kernel:activity1:Activity:assignedTo",
551       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
552       operator,
553       values
554     );
555   }
556 
557   public void thereExistsAssignedTo (
558     short operator,
559     java.util.Collection   values
560   ) {
561     refAddValue(
562       "org:opencrx:kernel:activity1:Activity:assignedTo",
563       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
564       operator,
565       values
566     );
567   }
568       
569 // ----------------------------------------------------------------------------
570 // Filter/ImplReference
571 // ----------------------------------------------------------------------------
572   public void forAllContract (
573     short operator,
574     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
575   ) {
576     java.util.List   arrayAsList = new java.util.ArrayList  ();
577     for(int i = 0; i < filterValues.length; i++) {
578       arrayAsList.add(
579         filterValues[i]
580       );
581     }
582     forAllContract (
583       operator,
584       arrayAsList
585     );
586   }
587 
588   public void thereExistsContract (
589     short operator,
590     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
591   ) {
592     java.util.List   arrayAsList = new java.util.ArrayList  ();
593     for(int i = 0; i < filterValues.length; i++) {
594       arrayAsList.add(
595         filterValues[i]
596       );
597     }
598     thereExistsContract (
599       operator,
600       arrayAsList
601     );
602   }
603 
604   public void forAllContract (
605     short operator,
606     java.util.Collection   values
607   ) {
608     refAddValue(
609       "org:opencrx:kernel:activity1:Activity:contract",
610       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
611       operator,
612       values
613     );
614   }
615 
616   public void thereExistsContract (
617     short operator,
618     java.util.Collection   values
619   ) {
620     refAddValue(
621       "org:opencrx:kernel:activity1:Activity:contract",
622       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
623       operator,
624       values
625     );
626   }
627       
628 // ----------------------------------------------------------------------------
629 // Filter/ImplAttributeIsNotStruct
630 // ----------------------------------------------------------------------------
631   public void forAllDescription (
632     short operator,
633     java.util.Collection   values
634   ) {
635     refAddValue(
636       "org:opencrx:kernel:activity1:Activity:description",
637       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
638       operator,
639       values
640     );
641   }
642 
643   public void thereExistsDescription (
644     short operator,
645     java.util.Collection   values
646   ) {
647     refAddValue(
648       "org:opencrx:kernel:activity1:Activity:description",
649       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
650       operator,
651       values
652     );
653   }
654 
655   public void forAllDescription (
656     short operator,
657     String  [] filterValues
658   ) {
659     java.util.List   arrayAsList = new java.util.ArrayList  ();
660     for(int i = 0; i < filterValues.length; i++) {
661       arrayAsList.add(
662         filterValues[i]
663       );
664     }
665     forAllDescription (
666       operator,
667       arrayAsList
668     );
669   }
670 
671   public void thereExistsDescription (
672     short operator,
673     String  [] filterValues
674   ) {
675     java.util.List   arrayAsList = new java.util.ArrayList  ();
676     for(int i = 0; i < filterValues.length; i++) {
677       arrayAsList.add(
678         filterValues[i]
679       );
680     }
681     thereExistsDescription (
682       operator,
683       arrayAsList
684     );
685   }
686 
687   public void orderByDescription (
688     short order
689   ) {
690     refAddValue(
691       "org:opencrx:kernel:activity1:Activity:description",
692       order
693     );
694   }
695       
696 // ----------------------------------------------------------------------------
697 // Filter/ImplAttributeIsNotStruct
698 // ----------------------------------------------------------------------------
699   public void forAllDetailedDescription (
700     short operator,
701     java.util.Collection   values
702   ) {
703     refAddValue(
704       "org:opencrx:kernel:activity1:Activity:detailedDescription",
705       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
706       operator,
707       values
708     );
709   }
710 
711   public void thereExistsDetailedDescription (
712     short operator,
713     java.util.Collection   values
714   ) {
715     refAddValue(
716       "org:opencrx:kernel:activity1:Activity:detailedDescription",
717       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
718       operator,
719       values
720     );
721   }
722 
723   public void forAllDetailedDescription (
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     forAllDetailedDescription (
734       operator,
735       arrayAsList
736     );
737   }
738 
739   public void thereExistsDetailedDescription (
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     thereExistsDetailedDescription (
750       operator,
751       arrayAsList
752     );
753   }
754 
755   public void orderByDetailedDescription (
756     short order
757   ) {
758     refAddValue(
759       "org:opencrx:kernel:activity1:Activity:detailedDescription",
760       order
761     );
762   }
763       
764 // ----------------------------------------------------------------------------
765 // Filter/ImplAttributeIsNotStruct
766 // ----------------------------------------------------------------------------
767   public void forAllDueBy (
768     short operator,
769     java.util.Collection   values
770   ) {
771     refAddValue(
772       "org:opencrx:kernel:activity1:Activity:dueBy",
773       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
774       operator,
775       values
776     );
777   }
778 
779   public void thereExistsDueBy (
780     short operator,
781     java.util.Collection   values
782   ) {
783     refAddValue(
784       "org:opencrx:kernel:activity1:Activity:dueBy",
785       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
786       operator,
787       values
788     );
789   }
790 
791   public void forAllDueBy (
792     short operator,
793     java.util.Date  [] 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     forAllDueBy (
802       operator,
803       arrayAsList
804     );
805   }
806 
807   public void thereExistsDueBy (
808     short operator,
809     java.util.Date  [] 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     thereExistsDueBy (
818       operator,
819       arrayAsList
820     );
821   }
822 
823   public void orderByDueBy (
824     short order
825   ) {
826     refAddValue(
827       "org:opencrx:kernel:activity1:Activity:dueBy",
828       order
829     );
830   }
831       
832 // ----------------------------------------------------------------------------
833 // Filter/ImplReference
834 // ----------------------------------------------------------------------------
835   public void forAllLastTransition (
836     short operator,
837     org.opencrx.kernel.activity1.cci.ActivityProcessTransition[] 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     forAllLastTransition (
846       operator,
847       arrayAsList
848     );
849   }
850 
851   public void thereExistsLastTransition (
852     short operator,
853     org.opencrx.kernel.activity1.cci.ActivityProcessTransition[] 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     thereExistsLastTransition (
862       operator,
863       arrayAsList
864     );
865   }
866 
867   public void forAllLastTransition (
868     short operator,
869     java.util.Collection   values
870   ) {
871     refAddValue(
872       "org:opencrx:kernel:activity1:Activity:lastTransition",
873       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
874       operator,
875       values
876     );
877   }
878 
879   public void thereExistsLastTransition (
880     short operator,
881     java.util.Collection   values
882   ) {
883     refAddValue(
884       "org:opencrx:kernel:activity1:Activity:lastTransition",
885       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
886       operator,
887       values
888     );
889   }
890       
891 // ----------------------------------------------------------------------------
892 // Filter/ImplAttributeIsNotStruct
893 // ----------------------------------------------------------------------------
894   public void forAllMisc1 (
895     short operator,
896     java.util.Collection   values
897   ) {
898     refAddValue(
899       "org:opencrx:kernel:activity1:Activity:misc1",
900       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
901       operator,
902       values
903     );
904   }
905 
906   public void thereExistsMisc1 (
907     short operator,
908     java.util.Collection   values
909   ) {
910     refAddValue(
911       "org:opencrx:kernel:activity1:Activity:misc1",
912       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
913       operator,
914       values
915     );
916   }
917 
918   public void forAllMisc1 (
919     short operator,
920     String  [] filterValues
921   ) {
922     java.util.List   arrayAsList = new java.util.ArrayList  ();
923     for(int i = 0; i < filterValues.length; i++) {
924       arrayAsList.add(
925         filterValues[i]
926       );
927     }
928     forAllMisc1 (
929       operator,
930       arrayAsList
931     );
932   }
933 
934   public void thereExistsMisc1 (
935     short operator,
936     String  [] filterValues
937   ) {
938     java.util.List   arrayAsList = new java.util.ArrayList  ();
939     for(int i = 0; i < filterValues.length; i++) {
940       arrayAsList.add(
941         filterValues[i]
942       );
943     }
944     thereExistsMisc1 (
945       operator,
946       arrayAsList
947     );
948   }
949 
950   public void orderByMisc1 (
951     short order
952   ) {
953     refAddValue(
954       "org:opencrx:kernel:activity1:Activity:misc1",
955       order
956     );
957   }
958       
959 // ----------------------------------------------------------------------------
960 // Filter/ImplAttributeIsNotStruct
961 // ----------------------------------------------------------------------------
962   public void forAllMisc2 (
963     short operator,
964     java.util.Collection   values
965   ) {
966     refAddValue(
967       "org:opencrx:kernel:activity1:Activity:misc2",
968       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
969       operator,
970       values
971     );
972   }
973 
974   public void thereExistsMisc2 (
975     short operator,
976     java.util.Collection   values
977   ) {
978     refAddValue(
979       "org:opencrx:kernel:activity1:Activity:misc2",
980       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
981       operator,
982       values
983     );
984   }
985 
986   public void forAllMisc2 (
987     short operator,
988     String  [] filterValues
989   ) {
990     java.util.List   arrayAsList = new java.util.ArrayList  ();
991     for(int i = 0; i < filterValues.length; i++) {
992       arrayAsList.add(
993         filterValues[i]
994       );
995     }
996     forAllMisc2 (
997       operator,
998       arrayAsList
999     );
1000  }
1001
1002  public void thereExistsMisc2 (
1003    short operator,
1004    String  [] filterValues
1005  ) {
1006    java.util.List   arrayAsList = new java.util.ArrayList  ();
1007    for(int i = 0; i < filterValues.length; i++) {
1008      arrayAsList.add(
1009        filterValues[i]
1010      );
1011    }
1012    thereExistsMisc2 (
1013      operator,
1014      arrayAsList
1015    );
1016  }
1017
1018  public void orderByMisc2 (
1019    short order
1020  ) {
1021    refAddValue(
1022      "org:opencrx:kernel:activity1:Activity:misc2",
1023      order
1024    );
1025  }
1026      
1027// ----------------------------------------------------------------------------
1028// Filter/ImplAttributeIsNotStruct
1029// ----------------------------------------------------------------------------
1030  public void forAllMisc3 (
1031    short operator,
1032    java.util.Collection   values
1033  ) {
1034    refAddValue(
1035      "org:opencrx:kernel:activity1:Activity:misc3",
1036      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1037      operator,
1038      values
1039    );
1040  }
1041
1042  public void thereExistsMisc3 (
1043    short operator,
1044    java.util.Collection   values
1045  ) {
1046    refAddValue(
1047      "org:opencrx:kernel:activity1:Activity:misc3",
1048      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1049      operator,
1050      values
1051    );
1052  }
1053
1054  public void forAllMisc3 (
1055    short operator,
1056    String  [] filterValues
1057  ) {
1058    java.util.List   arrayAsList = new java.util.ArrayList  ();
1059    for(int i = 0; i < filterValues.length; i++) {
1060      arrayAsList.add(
1061        filterValues[i]
1062      );
1063    }
1064    forAllMisc3 (
1065      operator,
1066      arrayAsList
1067    );
1068  }
1069
1070  public void thereExistsMisc3 (
1071    short operator,
1072    String  [] filterValues
1073  ) {
1074    java.util.List   arrayAsList = new java.util.ArrayList  ();
1075    for(int i = 0; i < filterValues.length; i++) {
1076      arrayAsList.add(
1077        filterValues[i]
1078      );
1079    }
1080    thereExistsMisc3 (
1081      operator,
1082      arrayAsList
1083    );
1084  }
1085
1086  public void orderByMisc3 (
1087    short order
1088  ) {
1089    refAddValue(
1090      "org:opencrx:kernel:activity1:Activity:misc3",
1091      order
1092    );
1093  }
1094      
1095// ----------------------------------------------------------------------------
1096// Filter/ImplAttributeIsNotStruct
1097// ----------------------------------------------------------------------------
1098  public void forAllName (
1099    short operator,
1100    java.util.Collection   values
1101  ) {
1102    refAddValue(
1103      "org:opencrx:kernel:activity1:Activity:name",
1104      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1105      operator,
1106      values
1107    );
1108  }
1109
1110  public void thereExistsName (
1111    short operator,
1112    java.util.Collection   values
1113  ) {
1114    refAddValue(
1115      "org:opencrx:kernel:activity1:Activity:name",
1116      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1117      operator,
1118      values
1119    );
1120  }
1121
1122  public void forAllName (
1123    short operator,
1124    String  [] filterValues
1125  ) {
1126    java.util.List   arrayAsList = new java.util.ArrayList  ();
1127    for(int i = 0; i < filterValues.length; i++) {
1128      arrayAsList.add(
1129        filterValues[i]
1130      );
1131    }
1132    forAllName (
1133      operator,
1134      arrayAsList
1135    );
1136  }
1137
1138  public void thereExistsName (
1139    short operator,
1140    String  [] filterValues
1141  ) {
1142    java.util.List   arrayAsList = new java.util.ArrayList  ();
1143    for(int i = 0; i < filterValues.length; i++) {
1144      arrayAsList.add(
1145        filterValues[i]
1146      );
1147    }
1148    thereExistsName (
1149      operator,
1150      arrayAsList
1151    );
1152  }
1153
1154  public void orderByName (
1155    short order
1156  ) {
1157    refAddValue(
1158      "org:opencrx:kernel:activity1:Activity:name",
1159      order
1160    );
1161  }
1162      
1163// ----------------------------------------------------------------------------
1164// Filter/ImplAttributeIsNotStruct
1165// ----------------------------------------------------------------------------
1166  public void forAllOriginalScheduledEnd (
1167    short operator,
1168    java.util.Collection   values
1169  ) {
1170    refAddValue(
1171      "org:opencrx:kernel:activity1:Activity:originalScheduledEnd",
1172      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1173      operator,
1174      values
1175    );
1176  }
1177
1178  public void thereExistsOriginalScheduledEnd (
1179    short operator,
1180    java.util.Collection   values
1181  ) {
1182    refAddValue(
1183      "org:opencrx:kernel:activity1:Activity:originalScheduledEnd",
1184      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1185      operator,
1186      values
1187    );
1188  }
1189
1190  public void forAllOriginalScheduledEnd (
1191    short operator,
1192    java.util.Date  [] filterValues
1193  ) {
1194    java.util.List   arrayAsList = new java.util.ArrayList  ();
1195    for(int i = 0; i < filterValues.length; i++) {
1196      arrayAsList.add(
1197        filterValues[i]
1198      );
1199    }
1200    forAllOriginalScheduledEnd (
1201      operator,
1202      arrayAsList
1203    );
1204  }
1205
1206  public void thereExistsOriginalScheduledEnd (
1207    short operator,
1208    java.util.Date  [] filterValues
1209  ) {
1210    java.util.List   arrayAsList = new java.util.ArrayList  ();
1211    for(int i = 0; i < filterValues.length; i++) {
1212      arrayAsList.add(
1213        filterValues[i]
1214      );
1215    }
1216    thereExistsOriginalScheduledEnd (
1217      operator,
1218      arrayAsList
1219    );
1220  }
1221
1222  public void orderByOriginalScheduledEnd (
1223    short order
1224  ) {
1225    refAddValue(
1226      "org:opencrx:kernel:activity1:Activity:originalScheduledEnd",
1227      order
1228    );
1229  }
1230      
1231// ----------------------------------------------------------------------------
1232// Filter/ImplAttributeIsNotStruct
1233// ----------------------------------------------------------------------------
1234  public void forAllPercentComplete (
1235    short operator,
1236    java.util.Collection   values
1237  ) {
1238    refAddValue(
1239      "org:opencrx:kernel:activity1:Activity:percentComplete",
1240      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1241      operator,
1242      values
1243    );
1244  }
1245
1246  public void thereExistsPercentComplete (
1247    short operator,
1248    java.util.Collection   values
1249  ) {
1250    refAddValue(
1251      "org:opencrx:kernel:activity1:Activity:percentComplete",
1252      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1253      operator,
1254      values
1255    );
1256  }
1257
1258  public void forAllPercentComplete (
1259    short operator,
1260    short[] filterValues
1261  ) {
1262    java.util.List   arrayAsList = new java.util.ArrayList  ();
1263    for(int i = 0; i < filterValues.length; i++) {
1264      arrayAsList.add(
1265        new Short  (filterValues[i])
1266      );
1267    }
1268    forAllPercentComplete (
1269      operator,
1270      arrayAsList
1271    );
1272  }
1273
1274  public void thereExistsPercentComplete (
1275    short operator,
1276    short[] filterValues
1277  ) {
1278    java.util.List   arrayAsList = new java.util.ArrayList  ();
1279    for(int i = 0; i < filterValues.length; i++) {
1280      arrayAsList.add(
1281        new Short  (filterValues[i])
1282      );
1283    }
1284    thereExistsPercentComplete (
1285      operator,
1286      arrayAsList
1287    );
1288  }
1289
1290  public void orderByPercentComplete (
1291    short order
1292  ) {
1293    refAddValue(
1294      "org:opencrx:kernel:activity1:Activity:percentComplete",
1295      order
1296    );
1297  }
1298      
1299// ----------------------------------------------------------------------------
1300// Filter/ImplAttributeIsNotStruct
1301// ----------------------------------------------------------------------------
1302  public void forAllPriority (
1303    short operator,
1304    java.util.Collection   values
1305  ) {
1306    refAddValue(
1307      "org:opencrx:kernel:activity1:Activity:priority",
1308      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1309      operator,
1310      values
1311    );
1312  }
1313
1314  public void thereExistsPriority (
1315    short operator,
1316    java.util.Collection   values
1317  ) {
1318    refAddValue(
1319      "org:opencrx:kernel:activity1:Activity:priority",
1320      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1321      operator,
1322      values
1323    );
1324  }
1325
1326  public void forAllPriority (
1327    short operator,
1328    short[] filterValues
1329  ) {
1330    java.util.List   arrayAsList = new java.util.ArrayList  ();
1331    for(int i = 0; i < filterValues.length; i++) {
1332      arrayAsList.add(
1333        new Short  (filterValues[i])
1334      );
1335    }
1336    forAllPriority (
1337      operator,
1338      arrayAsList
1339    );
1340  }
1341
1342  public void thereExistsPriority (
1343    short operator,
1344    short[] filterValues
1345  ) {
1346    java.util.List   arrayAsList = new java.util.ArrayList  ();
1347    for(int i = 0; i < filterValues.length; i++) {
1348      arrayAsList.add(
1349        new Short  (filterValues[i])
1350      );
1351    }
1352    thereExistsPriority (
1353      operator,
1354      arrayAsList
1355    );
1356  }
1357
1358  public void orderByPriority (
1359    short order
1360  ) {
1361    refAddValue(
1362      "org:opencrx:kernel:activity1:Activity:priority",
1363      order
1364    );
1365  }
1366      
1367// ----------------------------------------------------------------------------
1368// Filter/ImplReference
1369// ----------------------------------------------------------------------------
1370  public void forAllProcessState (
1371    short operator,
1372    org.opencrx.kernel.activity1.cci.ActivityProcessState[] filterValues
1373  ) {
1374    java.util.List   arrayAsList = new java.util.ArrayList  ();
1375    for(int i = 0; i < filterValues.length; i++) {
1376      arrayAsList.add(
1377        filterValues[i]
1378      );
1379    }
1380    forAllProcessState (
1381      operator,
1382      arrayAsList
1383    );
1384  }
1385
1386  public void thereExistsProcessState (
1387    short operator,
1388    org.opencrx.kernel.activity1.cci.ActivityProcessState[] filterValues
1389  ) {
1390    java.util.List   arrayAsList = new java.util.ArrayList  ();
1391    for(int i = 0; i < filterValues.length; i++) {
1392      arrayAsList.add(
1393        filterValues[i]
1394      );
1395    }
1396    thereExistsProcessState (
1397      operator,
1398      arrayAsList
1399    );
1400  }
1401
1402  public void forAllProcessState (
1403    short operator,
1404    java.util.Collection   values
1405  ) {
1406    refAddValue(
1407      "org:opencrx:kernel:activity1:Activity:processState",
1408      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1409      operator,
1410      values
1411    );
1412  }
1413
1414  public void thereExistsProcessState (
1415    short operator,
1416    java.util.Collection   values
1417  ) {
1418    refAddValue(
1419      "org:opencrx:kernel:activity1:Activity:processState",
1420      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1421      operator,
1422      values
1423    );
1424  }
1425      
1426// ----------------------------------------------------------------------------
1427// Filter/ImplReference
1428// ----------------------------------------------------------------------------
1429  public void forAllReportingAccount (
1430    short operator,
1431    org.opencrx.kernel.account1.cci.Account[] filterValues
1432  ) {
1433    java.util.List   arrayAsList = new java.util.ArrayList  ();
1434    for(int i = 0; i < filterValues.length; i++) {
1435      arrayAsList.add(
1436        filterValues[i]
1437      );
1438    }
1439    forAllReportingAccount (
1440      operator,
1441      arrayAsList
1442    );
1443  }
1444
1445  public void thereExistsReportingAccount (
1446    short operator,
1447    org.opencrx.kernel.account1.cci.Account[] filterValues
1448  ) {
1449    java.util.List   arrayAsList = new java.util.ArrayList  ();
1450    for(int i = 0; i < filterValues.length; i++) {
1451      arrayAsList.add(
1452        filterValues[i]
1453      );
1454    }
1455    thereExistsReportingAccount (
1456      operator,
1457      arrayAsList
1458    );
1459  }
1460
1461  public void forAllReportingAccount (
1462    short operator,
1463    java.util.Collection   values
1464  ) {
1465    refAddValue(
1466      "org:opencrx:kernel:activity1:Activity:reportingAccount",
1467      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1468      operator,
1469      values
1470    );
1471  }
1472
1473  public void thereExistsReportingAccount (
1474    short operator,
1475    java.util.Collection   values
1476  ) {
1477    refAddValue(
1478      "org:opencrx:kernel:activity1:Activity:reportingAccount",
1479      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1480      operator,
1481      values
1482    );
1483  }
1484      
1485// ----------------------------------------------------------------------------
1486// Filter/ImplReference
1487// ----------------------------------------------------------------------------
1488  public void forAllReportingContact (
1489    short operator,
1490    org.opencrx.kernel.account1.cci.Contact[] filterValues
1491  ) {
1492    java.util.List   arrayAsList = new java.util.ArrayList  ();
1493    for(int i = 0; i < filterValues.length; i++) {
1494      arrayAsList.add(
1495        filterValues[i]
1496      );
1497    }
1498    forAllReportingContact (
1499      operator,
1500      arrayAsList
1501    );
1502  }
1503
1504  public void thereExistsReportingContact (
1505    short operator,
1506    org.opencrx.kernel.account1.cci.Contact[] filterValues
1507  ) {
1508    java.util.List   arrayAsList = new java.util.ArrayList  ();
1509    for(int i = 0; i < filterValues.length; i++) {
1510      arrayAsList.add(
1511        filterValues[i]
1512      );
1513    }
1514    thereExistsReportingContact (
1515      operator,
1516      arrayAsList
1517    );
1518  }
1519
1520  public void forAllReportingContact (
1521    short operator,
1522    java.util.Collection   values
1523  ) {
1524    refAddValue(
1525      "org:opencrx:kernel:activity1:Activity:reportingContact",
1526      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1527      operator,
1528      values
1529    );
1530  }
1531
1532  public void thereExistsReportingContact (
1533    short operator,
1534    java.util.Collection   values
1535  ) {
1536    refAddValue(
1537      "org:opencrx:kernel:activity1:Activity:reportingContact",
1538      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1539      operator,
1540      values
1541    );
1542  }
1543      
1544// ----------------------------------------------------------------------------
1545// Filter/ImplAttributeIsNotStruct
1546// ----------------------------------------------------------------------------
1547  public void forAllScheduledEnd (
1548    short operator,
1549    java.util.Collection   values
1550  ) {
1551    refAddValue(
1552      "org:opencrx:kernel:activity1:Activity:scheduledEnd",
1553      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1554      operator,
1555      values
1556    );
1557  }
1558
1559  public void thereExistsScheduledEnd (
1560    short operator,
1561    java.util.Collection   values
1562  ) {
1563    refAddValue(
1564      "org:opencrx:kernel:activity1:Activity:scheduledEnd",
1565      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1566      operator,
1567      values
1568    );
1569  }
1570
1571  public void forAllScheduledEnd (
1572    short operator,
1573    java.util.Date  [] filterValues
1574  ) {
1575    java.util.List   arrayAsList = new java.util.ArrayList  ();
1576    for(int i = 0; i < filterValues.length; i++) {
1577      arrayAsList.add(
1578        filterValues[i]
1579      );
1580    }
1581    forAllScheduledEnd (
1582      operator,
1583      arrayAsList
1584    );
1585  }
1586
1587  public void thereExistsScheduledEnd (
1588    short operator,
1589    java.util.Date  [] filterValues
1590  ) {
1591    java.util.List   arrayAsList = new java.util.ArrayList  ();
1592    for(int i = 0; i < filterValues.length; i++) {
1593      arrayAsList.add(
1594        filterValues[i]
1595      );
1596    }
1597    thereExistsScheduledEnd (
1598      operator,
1599      arrayAsList
1600    );
1601  }
1602
1603  public void orderByScheduledEnd (
1604    short order
1605  ) {
1606    refAddValue(
1607      "org:opencrx:kernel:activity1:Activity:scheduledEnd",
1608      order
1609    );
1610  }
1611      
1612// ----------------------------------------------------------------------------
1613// Filter/ImplAttributeIsNotStruct
1614// ----------------------------------------------------------------------------
1615  public void forAllScheduledStart (
1616    short operator,
1617    java.util.Collection   values
1618  ) {
1619    refAddValue(
1620      "org:opencrx:kernel:activity1:Activity:scheduledStart",
1621      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1622      operator,
1623      values
1624    );
1625  }
1626
1627  public void thereExistsScheduledStart (
1628    short operator,
1629    java.util.Collection   values
1630  ) {
1631    refAddValue(
1632      "org:opencrx:kernel:activity1:Activity:scheduledStart",
1633      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1634      operator,
1635      values
1636    );
1637  }
1638
1639  public void forAllScheduledStart (
1640    short operator,
1641    java.util.Date  [] filterValues
1642  ) {
1643    java.util.List   arrayAsList = new java.util.ArrayList  ();
1644    for(int i = 0; i < filterValues.length; i++) {
1645      arrayAsList.add(
1646        filterValues[i]
1647      );
1648    }
1649    forAllScheduledStart (
1650      operator,
1651      arrayAsList
1652    );
1653  }
1654
1655  public void thereExistsScheduledStart (
1656    short operator,
1657    java.util.Date  [] filterValues
1658  ) {
1659    java.util.List   arrayAsList = new java.util.ArrayList  ();
1660    for(int i = 0; i < filterValues.length; i++) {
1661      arrayAsList.add(
1662        filterValues[i]
1663      );
1664    }
1665    thereExistsScheduledStart (
1666      operator,
1667      arrayAsList
1668    );
1669  }
1670
1671  public void orderByScheduledStart (
1672    short order
1673  ) {
1674    refAddValue(
1675      "org:opencrx:kernel:activity1:Activity:scheduledStart",
1676      order
1677    );
1678  }
1679      
1680// ----------------------------------------------------------------------------
1681// Filter/ImplAttributeIsNotStruct
1682// ----------------------------------------------------------------------------
1683  public void forAllTotalVotes (
1684    short operator,
1685    java.util.Collection   values
1686  ) {
1687    refAddValue(
1688      "org:opencrx:kernel:activity1:Activity:totalVotes",
1689      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1690      operator,
1691      values
1692    );
1693  }
1694
1695  public void thereExistsTotalVotes (
1696    short operator,
1697    java.util.Collection   values
1698  ) {
1699    refAddValue(
1700      "org:opencrx:kernel:activity1:Activity:totalVotes",
1701      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1702      operator,
1703      values
1704    );
1705  }
1706
1707  public void forAllTotalVotes (
1708    short operator,
1709    int[] filterValues
1710  ) {
1711    java.util.List   arrayAsList = new java.util.ArrayList  ();
1712    for(int i = 0; i < filterValues.length; i++) {
1713      arrayAsList.add(
1714        new Integer  (filterValues[i])
1715      );
1716    }
1717    forAllTotalVotes (
1718      operator,
1719      arrayAsList
1720    );
1721  }
1722
1723  public void thereExistsTotalVotes (
1724    short operator,
1725    int[] filterValues
1726  ) {
1727    java.util.List   arrayAsList = new java.util.ArrayList  ();
1728    for(int i = 0; i < filterValues.length; i++) {
1729      arrayAsList.add(
1730        new Integer  (filterValues[i])
1731      );
1732    }
1733    thereExistsTotalVotes (
1734      operator,
1735      arrayAsList
1736    );
1737  }
1738
1739  public void orderByTotalVotes (
1740    short order
1741  ) {
1742    refAddValue(
1743      "org:opencrx:kernel:activity1:Activity:totalVotes",
1744      order
1745    );
1746  }
1747      
1748// ----------------------------------------------------------------------------
1749// Filter/ImplAttributeIsNotStruct
1750// ----------------------------------------------------------------------------
1751  public void forAllAccessLevelBrowse (
1752    short operator,
1753    java.util.Collection   values
1754  ) {
1755    refAddValue(
1756      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1757      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1758      operator,
1759      values
1760    );
1761  }
1762
1763  public void thereExistsAccessLevelBrowse (
1764    short operator,
1765    java.util.Collection   values
1766  ) {
1767    refAddValue(
1768      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1769      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1770      operator,
1771      values
1772    );
1773  }
1774
1775  public void forAllAccessLevelBrowse (
1776    short operator,
1777    short[] filterValues
1778  ) {
1779    java.util.List   arrayAsList = new java.util.ArrayList  ();
1780    for(int i = 0; i < filterValues.length; i++) {
1781      arrayAsList.add(
1782        new Short  (filterValues[i])
1783      );
1784    }
1785    forAllAccessLevelBrowse (
1786      operator,
1787      arrayAsList
1788    );
1789  }
1790
1791  public void thereExistsAccessLevelBrowse (
1792    short operator,
1793    short[] filterValues
1794  ) {
1795    java.util.List   arrayAsList = new java.util.ArrayList  ();
1796    for(int i = 0; i < filterValues.length; i++) {
1797      arrayAsList.add(
1798        new Short  (filterValues[i])
1799      );
1800    }
1801    thereExistsAccessLevelBrowse (
1802      operator,
1803      arrayAsList
1804    );
1805  }
1806
1807  public void orderByAccessLevelBrowse (
1808    short order
1809  ) {
1810    refAddValue(
1811      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1812      order
1813    );
1814  }
1815      
1816// ----------------------------------------------------------------------------
1817// Filter/ImplAttributeIsNotStruct
1818// ----------------------------------------------------------------------------
1819  public void forAllAccessLevelDelete (
1820    short operator,
1821    java.util.Collection   values
1822  ) {
1823    refAddValue(
1824      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1825      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1826      operator,
1827      values
1828    );
1829  }
1830
1831  public void thereExistsAccessLevelDelete (
1832    short operator,
1833    java.util.Collection   values
1834  ) {
1835    refAddValue(
1836      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1837      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1838      operator,
1839      values
1840    );
1841  }
1842
1843  public void forAllAccessLevelDelete (
1844    short operator,
1845    short[] filterValues
1846  ) {
1847    java.util.List   arrayAsList = new java.util.ArrayList  ();
1848    for(int i = 0; i < filterValues.length; i++) {
1849      arrayAsList.add(
1850        new Short  (filterValues[i])
1851      );
1852    }
1853    forAllAccessLevelDelete (
1854      operator,
1855      arrayAsList
1856    );
1857  }
1858
1859  public void thereExistsAccessLevelDelete (
1860    short operator,
1861    short[] filterValues
1862  ) {
1863    java.util.List   arrayAsList = new java.util.ArrayList  ();
1864    for(int i = 0; i < filterValues.length; i++) {
1865      arrayAsList.add(
1866        new Short  (filterValues[i])
1867      );
1868    }
1869    thereExistsAccessLevelDelete (
1870      operator,
1871      arrayAsList
1872    );
1873  }
1874
1875  public void orderByAccessLevelDelete (
1876    short order
1877  ) {
1878    refAddValue(
1879      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1880      order
1881    );
1882  }
1883      
1884// ----------------------------------------------------------------------------
1885// Filter/ImplAttributeIsNotStruct
1886// ----------------------------------------------------------------------------
1887  public void forAllAccessLevelUpdate (
1888    short operator,
1889    java.util.Collection   values
1890  ) {
1891    refAddValue(
1892      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1893      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1894      operator,
1895      values
1896    );
1897  }
1898
1899  public void thereExistsAccessLevelUpdate (
1900    short operator,
1901    java.util.Collection   values
1902  ) {
1903    refAddValue(
1904      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1905      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1906      operator,
1907      values
1908    );
1909  }
1910
1911  public void forAllAccessLevelUpdate (
1912    short operator,
1913    short[] filterValues
1914  ) {
1915    java.util.List   arrayAsList = new java.util.ArrayList  ();
1916    for(int i = 0; i < filterValues.length; i++) {
1917      arrayAsList.add(
1918        new Short  (filterValues[i])
1919      );
1920    }
1921    forAllAccessLevelUpdate (
1922      operator,
1923      arrayAsList
1924    );
1925  }
1926
1927  public void thereExistsAccessLevelUpdate (
1928    short operator,
1929    short[] filterValues
1930  ) {
1931    java.util.List   arrayAsList = new java.util.ArrayList  ();
1932    for(int i = 0; i < filterValues.length; i++) {
1933      arrayAsList.add(
1934        new Short  (filterValues[i])
1935      );
1936    }
1937    thereExistsAccessLevelUpdate (
1938      operator,
1939      arrayAsList
1940    );
1941  }
1942
1943  public void orderByAccessLevelUpdate (
1944    short order
1945  ) {
1946    refAddValue(
1947      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1948      order
1949    );
1950  }
1951      
1952// ----------------------------------------------------------------------------
1953// Filter/ImplAttributeIsNotStruct
1954// ----------------------------------------------------------------------------
1955  public void forAllOwner (
1956    short operator,
1957    java.util.Collection   values
1958  ) {
1959    refAddValue(
1960      "org:opencrx:kernel:base:SecureObject:owner",
1961      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1962      operator,
1963      values
1964    );
1965  }
1966
1967  public void thereExistsOwner (
1968    short operator,
1969    java.util.Collection   values
1970  ) {
1971    refAddValue(
1972      "org:opencrx:kernel:base:SecureObject:owner",
1973      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1974      operator,
1975      values
1976    );
1977  }
1978
1979  public void forAllOwner (
1980    short operator,
1981    String  [] filterValues
1982  ) {
1983    java.util.List   arrayAsList = new java.util.ArrayList  ();
1984    for(int i = 0; i < filterValues.length; i++) {
1985      arrayAsList.add(
1986        filterValues[i]
1987      );
1988    }
1989    forAllOwner (
1990      operator,
1991      arrayAsList
1992    );
1993  }
1994
1995  public void thereExistsOwner (
1996    short operator,
1997    String  [] filterValues
1998  ) {
1999    java.util.List   arrayAsList = new java.util.ArrayList  ();
2000    for(int i = 0; i < filterValues.length; i++) {
2001      arrayAsList.add(
2002        filterValues[i]
2003      );
2004    }
2005    thereExistsOwner (
2006      operator,
2007      arrayAsList
2008    );
2009  }
2010
2011  public void orderByOwner (
2012    short order
2013  ) {
2014    refAddValue(
2015      "org:opencrx:kernel:base:SecureObject:owner",
2016      order
2017    );
2018  }
2019      
2020// ----------------------------------------------------------------------------
2021// Filter/ImplReference
2022// ----------------------------------------------------------------------------
2023  public void forAllOwningGroup (
2024    short operator,
2025    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2026  ) {
2027    java.util.List   arrayAsList = new java.util.ArrayList  ();
2028    for(int i = 0; i < filterValues.length; i++) {
2029      arrayAsList.add(
2030        filterValues[i]
2031      );
2032    }
2033    forAllOwningGroup (
2034      operator,
2035      arrayAsList
2036    );
2037  }
2038
2039  public void thereExistsOwningGroup (
2040    short operator,
2041    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2042  ) {
2043    java.util.List   arrayAsList = new java.util.ArrayList  ();
2044    for(int i = 0; i < filterValues.length; i++) {
2045      arrayAsList.add(
2046        filterValues[i]
2047      );
2048    }
2049    thereExistsOwningGroup (
2050      operator,
2051      arrayAsList
2052    );
2053  }
2054
2055  public void forAllOwningGroup (
2056    short operator,
2057    java.util.Collection   values
2058  ) {
2059    refAddValue(
2060      "org:opencrx:kernel:base:SecureObject:owningGroup",
2061      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2062      operator,
2063      values
2064    );
2065  }
2066
2067  public void thereExistsOwningGroup (
2068    short operator,
2069    java.util.Collection   values
2070  ) {
2071    refAddValue(
2072      "org:opencrx:kernel:base:SecureObject:owningGroup",
2073      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2074      operator,
2075      values
2076    );
2077  }
2078      
2079// ----------------------------------------------------------------------------
2080// Filter/ImplReference
2081// ----------------------------------------------------------------------------
2082  public void forAllOwningUser (
2083    short operator,
2084    org.opencrx.security.realm1.cci.User[] filterValues
2085  ) {
2086    java.util.List   arrayAsList = new java.util.ArrayList  ();
2087    for(int i = 0; i < filterValues.length; i++) {
2088      arrayAsList.add(
2089        filterValues[i]
2090      );
2091    }
2092    forAllOwningUser (
2093      operator,
2094      arrayAsList
2095    );
2096  }
2097
2098  public void thereExistsOwningUser (
2099    short operator,
2100    org.opencrx.security.realm1.cci.User[] filterValues
2101  ) {
2102    java.util.List   arrayAsList = new java.util.ArrayList  ();
2103    for(int i = 0; i < filterValues.length; i++) {
2104      arrayAsList.add(
2105        filterValues[i]
2106      );
2107    }
2108    thereExistsOwningUser (
2109      operator,
2110      arrayAsList
2111    );
2112  }
2113
2114  public void forAllOwningUser (
2115    short operator,
2116    java.util.Collection   values
2117  ) {
2118    refAddValue(
2119      "org:opencrx:kernel:base:SecureObject:owningUser",
2120      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2121      operator,
2122      values
2123    );
2124  }
2125
2126  public void thereExistsOwningUser (
2127    short operator,
2128    java.util.Collection   values
2129  ) {
2130    refAddValue(
2131      "org:opencrx:kernel:base:SecureObject:owningUser",
2132      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2133      operator,
2134      values
2135    );
2136  }
2137      
2138// ----------------------------------------------------------------------------
2139// Filter/ImplAttributeIsNotStruct
2140// ----------------------------------------------------------------------------
2141  public void forAllCategory (
2142    short operator,
2143    java.util.Collection   values
2144  ) {
2145    refAddValue(
2146      "org:opencrx:kernel:generic:CrxObject:category",
2147      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2148      operator,
2149      values
2150    );
2151  }
2152
2153  public void thereExistsCategory (
2154    short operator,
2155    java.util.Collection   values
2156  ) {
2157    refAddValue(
2158      "org:opencrx:kernel:generic:CrxObject:category",
2159      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2160      operator,
2161      values
2162    );
2163  }
2164
2165  public void forAllCategory (
2166    short operator,
2167    String  [] filterValues
2168  ) {
2169    java.util.List   arrayAsList = new java.util.ArrayList  ();
2170    for(int i = 0; i < filterValues.length; i++) {
2171      arrayAsList.add(
2172        filterValues[i]
2173      );
2174    }
2175    forAllCategory (
2176      operator,
2177      arrayAsList
2178    );
2179  }
2180
2181  public void thereExistsCategory (
2182    short operator,
2183    String  [] filterValues
2184  ) {
2185    java.util.List   arrayAsList = new java.util.ArrayList  ();
2186    for(int i = 0; i < filterValues.length; i++) {
2187      arrayAsList.add(
2188        filterValues[i]
2189      );
2190    }
2191    thereExistsCategory (
2192      operator,
2193      arrayAsList
2194    );
2195  }
2196
2197  public void orderByCategory (
2198    short order
2199  ) {
2200    refAddValue(
2201      "org:opencrx:kernel:generic:CrxObject:category",
2202      order
2203    );
2204  }
2205      
2206// ----------------------------------------------------------------------------
2207// Filter/ImplAttributeIsNotStruct
2208// ----------------------------------------------------------------------------
2209  public void forAllDisabled (
2210    short operator,
2211    java.util.Collection   values
2212  ) {
2213    refAddValue(
2214      "org:opencrx:kernel:generic:CrxObject:disabled",
2215      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2216      operator,
2217      values
2218    );
2219  }
2220
2221  public void thereExistsDisabled (
2222    short operator,
2223    java.util.Collection   values
2224  ) {
2225    refAddValue(
2226      "org:opencrx:kernel:generic:CrxObject:disabled",
2227      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2228      operator,
2229      values
2230    );
2231  }
2232
2233  public void forAllDisabled (
2234    short operator,
2235    boolean[] filterValues
2236  ) {
2237    java.util.List   arrayAsList = new java.util.ArrayList  ();
2238    for(int i = 0; i < filterValues.length; i++) {
2239      arrayAsList.add(
2240        new Boolean  (filterValues[i])
2241      );
2242    }
2243    forAllDisabled (
2244      operator,
2245      arrayAsList
2246    );
2247  }
2248
2249  public void thereExistsDisabled (
2250    short operator,
2251    boolean[] filterValues
2252  ) {
2253    java.util.List   arrayAsList = new java.util.ArrayList  ();
2254    for(int i = 0; i < filterValues.length; i++) {
2255      arrayAsList.add(
2256        new Boolean  (filterValues[i])
2257      );
2258    }
2259    thereExistsDisabled (
2260      operator,
2261      arrayAsList
2262    );
2263  }
2264
2265  public void orderByDisabled (
2266    short order
2267  ) {
2268    refAddValue(
2269      "org:opencrx:kernel:generic:CrxObject:disabled",
2270      order
2271    );
2272  }
2273      
2274// ----------------------------------------------------------------------------
2275// Filter/ImplAttributeIsNotStruct
2276// ----------------------------------------------------------------------------
2277  public void forAllDisabledReason (
2278    short operator,
2279    java.util.Collection   values
2280  ) {
2281    refAddValue(
2282      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2283      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2284      operator,
2285      values
2286    );
2287  }
2288
2289  public void thereExistsDisabledReason (
2290    short operator,
2291    java.util.Collection   values
2292  ) {
2293    refAddValue(
2294      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2295      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2296      operator,
2297      values
2298    );
2299  }
2300
2301  public void forAllDisabledReason (
2302    short operator,
2303    String  [] filterValues
2304  ) {
2305    java.util.List   arrayAsList = new java.util.ArrayList  ();
2306    for(int i = 0; i < filterValues.length; i++) {
2307      arrayAsList.add(
2308        filterValues[i]
2309      );
2310    }
2311    forAllDisabledReason (
2312      operator,
2313      arrayAsList
2314    );
2315  }
2316
2317  public void thereExistsDisabledReason (
2318    short operator,
2319    String  [] filterValues
2320  ) {
2321    java.util.List   arrayAsList = new java.util.ArrayList  ();
2322    for(int i = 0; i < filterValues.length; i++) {
2323      arrayAsList.add(
2324        filterValues[i]
2325      );
2326    }
2327    thereExistsDisabledReason (
2328      operator,
2329      arrayAsList
2330    );
2331  }
2332
2333  public void orderByDisabledReason (
2334    short order
2335  ) {
2336    refAddValue(
2337      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2338      order
2339    );
2340  }
2341      
2342// ----------------------------------------------------------------------------
2343// Filter/ImplAttributeIsNotStruct
2344// ----------------------------------------------------------------------------
2345  public void forAllExternalLink (
2346    short operator,
2347    java.util.Collection   values
2348  ) {
2349    refAddValue(
2350      "org:opencrx:kernel:generic:CrxObject:externalLink",
2351      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2352      operator,
2353      values
2354    );
2355  }
2356
2357  public void thereExistsExternalLink (
2358    short operator,
2359    java.util.Collection   values
2360  ) {
2361    refAddValue(
2362      "org:opencrx:kernel:generic:CrxObject:externalLink",
2363      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2364      operator,
2365      values
2366    );
2367  }
2368
2369  public void forAllExternalLink (
2370    short operator,
2371    String  [] filterValues
2372  ) {
2373    java.util.List   arrayAsList = new java.util.ArrayList  ();
2374    for(int i = 0; i < filterValues.length; i++) {
2375      arrayAsList.add(
2376        filterValues[i]
2377      );
2378    }
2379    forAllExternalLink (
2380      operator,
2381      arrayAsList
2382    );
2383  }
2384
2385  public void thereExistsExternalLink (
2386    short operator,
2387    String  [] filterValues
2388  ) {
2389    java.util.List   arrayAsList = new java.util.ArrayList  ();
2390    for(int i = 0; i < filterValues.length; i++) {
2391      arrayAsList.add(
2392        filterValues[i]
2393      );
2394    }
2395    thereExistsExternalLink (
2396      operator,
2397      arrayAsList
2398    );
2399  }
2400
2401  public void orderByExternalLink (
2402    short order
2403  ) {
2404    refAddValue(
2405      "org:opencrx:kernel:generic:CrxObject:externalLink",
2406      order
2407    );
2408  }
2409      
2410// ----------------------------------------------------------------------------
2411// Filter/ImplAttributeIsNotStruct
2412// ----------------------------------------------------------------------------
2413  public void forAllUserBoolean0 (
2414    short operator,
2415    java.util.Collection   values
2416  ) {
2417    refAddValue(
2418      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2419      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2420      operator,
2421      values
2422    );
2423  }
2424
2425  public void thereExistsUserBoolean0 (
2426    short operator,
2427    java.util.Collection   values
2428  ) {
2429    refAddValue(
2430      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2431      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2432      operator,
2433      values
2434    );
2435  }
2436
2437  public void forAllUserBoolean0 (
2438    short operator,
2439    boolean[] filterValues
2440  ) {
2441    java.util.List   arrayAsList = new java.util.ArrayList  ();
2442    for(int i = 0; i < filterValues.length; i++) {
2443      arrayAsList.add(
2444        new Boolean  (filterValues[i])
2445      );
2446    }
2447    forAllUserBoolean0 (
2448      operator,
2449      arrayAsList
2450    );
2451  }
2452
2453  public void thereExistsUserBoolean0 (
2454    short operator,
2455    boolean[] filterValues
2456  ) {
2457    java.util.List   arrayAsList = new java.util.ArrayList  ();
2458    for(int i = 0; i < filterValues.length; i++) {
2459      arrayAsList.add(
2460        new Boolean  (filterValues[i])
2461      );
2462    }
2463    thereExistsUserBoolean0 (
2464      operator,
2465      arrayAsList
2466    );
2467  }
2468
2469  public void orderByUserBoolean0 (
2470    short order
2471  ) {
2472    refAddValue(
2473      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2474      order
2475    );
2476  }
2477      
2478// ----------------------------------------------------------------------------
2479// Filter/ImplAttributeIsNotStruct
2480// ----------------------------------------------------------------------------
2481  public void forAllUserBoolean1 (
2482    short operator,
2483    java.util.Collection   values
2484  ) {
2485    refAddValue(
2486      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2487      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2488      operator,
2489      values
2490    );
2491  }
2492
2493  public void thereExistsUserBoolean1 (
2494    short operator,
2495    java.util.Collection   values
2496  ) {
2497    refAddValue(
2498      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2499      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2500      operator,
2501      values
2502    );
2503  }
2504
2505  public void forAllUserBoolean1 (
2506    short operator,
2507    boolean[] filterValues
2508  ) {
2509    java.util.List   arrayAsList = new java.util.ArrayList  ();
2510    for(int i = 0; i < filterValues.length; i++) {
2511      arrayAsList.add(
2512        new Boolean  (filterValues[i])
2513      );
2514    }
2515    forAllUserBoolean1 (
2516      operator,
2517      arrayAsList
2518    );
2519  }
2520
2521  public void thereExistsUserBoolean1 (
2522    short operator,
2523    boolean[] filterValues
2524  ) {
2525    java.util.List   arrayAsList = new java.util.ArrayList  ();
2526    for(int i = 0; i < filterValues.length; i++) {
2527      arrayAsList.add(
2528        new Boolean  (filterValues[i])
2529      );
2530    }
2531    thereExistsUserBoolean1 (
2532      operator,
2533      arrayAsList
2534    );
2535  }
2536
2537  public void orderByUserBoolean1 (
2538    short order
2539  ) {
2540    refAddValue(
2541      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2542      order
2543    );
2544  }
2545      
2546// ----------------------------------------------------------------------------
2547// Filter/ImplAttributeIsNotStruct
2548// ----------------------------------------------------------------------------
2549  public void forAllUserBoolean2 (
2550    short operator,
2551    java.util.Collection   values
2552  ) {
2553    refAddValue(
2554      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2555      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2556      operator,
2557      values
2558    );
2559  }
2560
2561  public void thereExistsUserBoolean2 (
2562    short operator,
2563    java.util.Collection   values
2564  ) {
2565    refAddValue(
2566      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2567      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2568      operator,
2569      values
2570    );
2571  }
2572
2573  public void forAllUserBoolean2 (
2574    short operator,
2575    boolean[] filterValues
2576  ) {
2577    java.util.List   arrayAsList = new java.util.ArrayList  ();
2578    for(int i = 0; i < filterValues.length; i++) {
2579      arrayAsList.add(
2580        new Boolean  (filterValues[i])
2581      );
2582    }
2583    forAllUserBoolean2 (
2584      operator,
2585      arrayAsList
2586    );
2587  }
2588
2589  public void thereExistsUserBoolean2 (
2590    short operator,
2591    boolean[] filterValues
2592  ) {
2593    java.util.List   arrayAsList = new java.util.ArrayList  ();
2594    for(int i = 0; i < filterValues.length; i++) {
2595      arrayAsList.add(
2596        new Boolean  (filterValues[i])
2597      );
2598    }
2599    thereExistsUserBoolean2 (
2600      operator,
2601      arrayAsList
2602    );
2603  }
2604
2605  public void orderByUserBoolean2 (
2606    short order
2607  ) {
2608    refAddValue(
2609      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2610      order
2611    );
2612  }
2613      
2614// ----------------------------------------------------------------------------
2615// Filter/ImplAttributeIsNotStruct
2616// ----------------------------------------------------------------------------
2617  public void forAllUserBoolean3 (
2618    short operator,
2619    java.util.Collection   values
2620  ) {
2621    refAddValue(
2622      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2623      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2624      operator,
2625      values
2626    );
2627  }
2628
2629  public void thereExistsUserBoolean3 (
2630    short operator,
2631    java.util.Collection   values
2632  ) {
2633    refAddValue(
2634      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2635      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2636      operator,
2637      values
2638    );
2639  }
2640
2641  public void forAllUserBoolean3 (
2642    short operator,
2643    boolean[] filterValues
2644  ) {
2645    java.util.List   arrayAsList = new java.util.ArrayList  ();
2646    for(int i = 0; i < filterValues.length; i++) {
2647      arrayAsList.add(
2648        new Boolean  (filterValues[i])
2649      );
2650    }
2651    forAllUserBoolean3 (
2652      operator,
2653      arrayAsList
2654    );
2655  }
2656
2657  public void thereExistsUserBoolean3 (
2658    short operator,
2659    boolean[] filterValues
2660  ) {
2661    java.util.List   arrayAsList = new java.util.ArrayList  ();
2662    for(int i = 0; i < filterValues.length; i++) {
2663      arrayAsList.add(
2664        new Boolean  (filterValues[i])
2665      );
2666    }
2667    thereExistsUserBoolean3 (
2668      operator,
2669      arrayAsList
2670    );
2671  }
2672
2673  public void orderByUserBoolean3 (
2674    short order
2675  ) {
2676    refAddValue(
2677      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2678      order
2679    );
2680  }
2681      
2682// ----------------------------------------------------------------------------
2683// Filter/ImplAttributeIsNotStruct
2684// ----------------------------------------------------------------------------
2685  public void forAllUserBoolean4 (
2686    short operator,
2687    java.util.Collection   values
2688  ) {
2689    refAddValue(
2690      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2691      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2692      operator,
2693      values
2694    );
2695  }
2696
2697  public void thereExistsUserBoolean4 (
2698    short operator,
2699    java.util.Collection   values
2700  ) {
2701    refAddValue(
2702      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2703      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2704      operator,
2705      values
2706    );
2707  }
2708
2709  public void forAllUserBoolean4 (
2710    short operator,
2711    boolean[] filterValues
2712  ) {
2713    java.util.List   arrayAsList = new java.util.ArrayList  ();
2714    for(int i = 0; i < filterValues.length; i++) {
2715      arrayAsList.add(
2716        new Boolean  (filterValues[i])
2717      );
2718    }
2719    forAllUserBoolean4 (
2720      operator,
2721      arrayAsList
2722    );
2723  }
2724
2725  public void thereExistsUserBoolean4 (
2726    short operator,
2727    boolean[] filterValues
2728  ) {
2729    java.util.List   arrayAsList = new java.util.ArrayList  ();
2730    for(int i = 0; i < filterValues.length; i++) {
2731      arrayAsList.add(
2732        new Boolean  (filterValues[i])
2733      );
2734    }
2735    thereExistsUserBoolean4 (
2736      operator,
2737      arrayAsList
2738    );
2739  }
2740
2741  public void orderByUserBoolean4 (
2742    short order
2743  ) {
2744    refAddValue(
2745      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2746      order
2747    );
2748  }
2749      
2750// ----------------------------------------------------------------------------
2751// Filter/ImplAttributeIsNotStruct
2752// ----------------------------------------------------------------------------
2753  public void forAllUserCode0 (
2754    short operator,
2755    java.util.Collection   values
2756  ) {
2757    refAddValue(
2758      "org:opencrx:kernel:generic:CrxObject:userCode0",
2759      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2760      operator,
2761      values
2762    );
2763  }
2764
2765  public void thereExistsUserCode0 (
2766    short operator,
2767    java.util.Collection   values
2768  ) {
2769    refAddValue(
2770      "org:opencrx:kernel:generic:CrxObject:userCode0",
2771      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2772      operator,
2773      values
2774    );
2775  }
2776
2777  public void forAllUserCode0 (
2778    short operator,
2779    short[] filterValues
2780  ) {
2781    java.util.List   arrayAsList = new java.util.ArrayList  ();
2782    for(int i = 0; i < filterValues.length; i++) {
2783      arrayAsList.add(
2784        new Short  (filterValues[i])
2785      );
2786    }
2787    forAllUserCode0 (
2788      operator,
2789      arrayAsList
2790    );
2791  }
2792
2793  public void thereExistsUserCode0 (
2794    short operator,
2795    short[] filterValues
2796  ) {
2797    java.util.List   arrayAsList = new java.util.ArrayList  ();
2798    for(int i = 0; i < filterValues.length; i++) {
2799      arrayAsList.add(
2800        new Short  (filterValues[i])
2801      );
2802    }
2803    thereExistsUserCode0 (
2804      operator,
2805      arrayAsList
2806    );
2807  }
2808
2809  public void orderByUserCode0 (
2810    short order
2811  ) {
2812    refAddValue(
2813      "org:opencrx:kernel:generic:CrxObject:userCode0",
2814      order
2815    );
2816  }
2817      
2818// ----------------------------------------------------------------------------
2819// Filter/ImplAttributeIsNotStruct
2820// ----------------------------------------------------------------------------
2821  public void forAllUserCode1 (
2822    short operator,
2823    java.util.Collection   values
2824  ) {
2825    refAddValue(
2826      "org:opencrx:kernel:generic:CrxObject:userCode1",
2827      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2828      operator,
2829      values
2830    );
2831  }
2832
2833  public void thereExistsUserCode1 (
2834    short operator,
2835    java.util.Collection   values
2836  ) {
2837    refAddValue(
2838      "org:opencrx:kernel:generic:CrxObject:userCode1",
2839      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2840      operator,
2841      values
2842    );
2843  }
2844
2845  public void forAllUserCode1 (
2846    short operator,
2847    short[] filterValues
2848  ) {
2849    java.util.List   arrayAsList = new java.util.ArrayList  ();
2850    for(int i = 0; i < filterValues.length; i++) {
2851      arrayAsList.add(
2852        new Short  (filterValues[i])
2853      );
2854    }
2855    forAllUserCode1 (
2856      operator,
2857      arrayAsList
2858    );
2859  }
2860
2861  public void thereExistsUserCode1 (
2862    short operator,
2863    short[] filterValues
2864  ) {
2865    java.util.List   arrayAsList = new java.util.ArrayList  ();
2866    for(int i = 0; i < filterValues.length; i++) {
2867      arrayAsList.add(
2868        new Short  (filterValues[i])
2869      );
2870    }
2871    thereExistsUserCode1 (
2872      operator,
2873      arrayAsList
2874    );
2875  }
2876
2877  public void orderByUserCode1 (
2878    short order
2879  ) {
2880    refAddValue(
2881      "org:opencrx:kernel:generic:CrxObject:userCode1",
2882      order
2883    );
2884  }
2885      
2886// ----------------------------------------------------------------------------
2887// Filter/ImplAttributeIsNotStruct
2888// ----------------------------------------------------------------------------
2889  public void forAllUserCode2 (
2890    short operator,
2891    java.util.Collection   values
2892  ) {
2893    refAddValue(
2894      "org:opencrx:kernel:generic:CrxObject:userCode2",
2895      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2896      operator,
2897      values
2898    );
2899  }
2900
2901  public void thereExistsUserCode2 (
2902    short operator,
2903    java.util.Collection   values
2904  ) {
2905    refAddValue(
2906      "org:opencrx:kernel:generic:CrxObject:userCode2",
2907      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2908      operator,
2909      values
2910    );
2911  }
2912
2913  public void forAllUserCode2 (
2914    short operator,
2915    short[] filterValues
2916  ) {
2917    java.util.List   arrayAsList = new java.util.ArrayList  ();
2918    for(int i = 0; i < filterValues.length; i++) {
2919      arrayAsList.add(
2920        new Short  (filterValues[i])
2921      );
2922    }
2923    forAllUserCode2 (
2924      operator,
2925      arrayAsList
2926    );
2927  }
2928
2929  public void thereExistsUserCode2 (
2930    short operator,
2931    short[] filterValues
2932  ) {
2933    java.util.List   arrayAsList = new java.util.ArrayList  ();
2934    for(int i = 0; i < filterValues.length; i++) {
2935      arrayAsList.add(
2936        new Short  (filterValues[i])
2937      );
2938    }
2939    thereExistsUserCode2 (
2940      operator,
2941      arrayAsList
2942    );
2943  }
2944
2945  public void orderByUserCode2 (
2946    short order
2947  ) {
2948    refAddValue(
2949      "org:opencrx:kernel:generic:CrxObject:userCode2",
2950      order
2951    );
2952  }
2953      
2954// ----------------------------------------------------------------------------
2955// Filter/ImplAttributeIsNotStruct
2956// ----------------------------------------------------------------------------
2957  public void forAllUserCode3 (
2958    short operator,
2959    java.util.Collection   values
2960  ) {
2961    refAddValue(
2962      "org:opencrx:kernel:generic:CrxObject:userCode3",
2963      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2964      operator,
2965      values
2966    );
2967  }
2968
2969  public void thereExistsUserCode3 (
2970    short operator,
2971    java.util.Collection   values
2972  ) {
2973    refAddValue(
2974      "org:opencrx:kernel:generic:CrxObject:userCode3",
2975      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2976      operator,
2977      values
2978    );
2979  }
2980
2981  public void forAllUserCode3 (
2982    short operator,
2983    short[] filterValues
2984  ) {
2985    java.util.List   arrayAsList = new java.util.ArrayList  ();
2986    for(int i = 0; i < filterValues.length; i++) {
2987      arrayAsList.add(
2988        new Short  (filterValues[i])
2989      );
2990    }
2991    forAllUserCode3 (
2992      operator,
2993      arrayAsList
2994    );
2995  }
2996
2997  public void thereExistsUserCode3 (
2998    short operator,
2999    short[] filterValues
3000  ) {
3001    java.util.List   arrayAsList = new java.util.ArrayList  ();
3002    for(int i = 0; i < filterValues.length; i++) {
3003      arrayAsList.add(
3004        new Short  (filterValues[i])
3005      );
3006    }
3007    thereExistsUserCode3 (
3008      operator,
3009      arrayAsList
3010    );
3011  }
3012
3013  public void orderByUserCode3 (
3014    short order
3015  ) {
3016    refAddValue(
3017      "org:opencrx:kernel:generic:CrxObject:userCode3",
3018      order
3019    );
3020  }
3021      
3022// ----------------------------------------------------------------------------
3023// Filter/ImplAttributeIsNotStruct
3024// ----------------------------------------------------------------------------
3025  public void forAllUserCode4 (
3026    short operator,
3027    java.util.Collection   values
3028  ) {
3029    refAddValue(
3030      "org:opencrx:kernel:generic:CrxObject:userCode4",
3031      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3032      operator,
3033      values
3034    );
3035  }
3036
3037  public void thereExistsUserCode4 (
3038    short operator,
3039    java.util.Collection   values
3040  ) {
3041    refAddValue(
3042      "org:opencrx:kernel:generic:CrxObject:userCode4",
3043      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3044      operator,
3045      values
3046    );
3047  }
3048
3049  public void forAllUserCode4 (
3050    short operator,
3051    short[] filterValues
3052  ) {
3053    java.util.List   arrayAsList = new java.util.ArrayList  ();
3054    for(int i = 0; i < filterValues.length; i++) {
3055      arrayAsList.add(
3056        new Short  (filterValues[i])
3057      );
3058    }
3059    forAllUserCode4 (
3060      operator,
3061      arrayAsList
3062    );
3063  }
3064
3065  public void thereExistsUserCode4 (
3066    short operator,
3067    short[] filterValues
3068  ) {
3069    java.util.List   arrayAsList = new java.util.ArrayList  ();
3070    for(int i = 0; i < filterValues.length; i++) {
3071      arrayAsList.add(
3072        new Short  (filterValues[i])
3073      );
3074    }
3075    thereExistsUserCode4 (
3076      operator,
3077      arrayAsList
3078    );
3079  }
3080
3081  public void orderByUserCode4 (
3082    short order
3083  ) {
3084    refAddValue(
3085      "org:opencrx:kernel:generic:CrxObject:userCode4",
3086      order
3087    );
3088  }
3089      
3090// ----------------------------------------------------------------------------
3091// Filter/ImplAttributeIsNotStruct
3092// ----------------------------------------------------------------------------
3093  public void forAllUserDate0 (
3094    short operator,
3095    java.util.Collection   values
3096  ) {
3097    refAddValue(
3098      "org:opencrx:kernel:generic:CrxObject:userDate0",
3099      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3100      operator,
3101      values
3102    );
3103  }
3104
3105  public void thereExistsUserDate0 (
3106    short operator,
3107    java.util.Collection   values
3108  ) {
3109    refAddValue(
3110      "org:opencrx:kernel:generic:CrxObject:userDate0",
3111      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3112      operator,
3113      values
3114    );
3115  }
3116
3117  public void forAllUserDate0 (
3118    short operator,
3119    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3120  ) {
3121    java.util.List   arrayAsList = new java.util.ArrayList  ();
3122    for(int i = 0; i < filterValues.length; i++) {
3123      arrayAsList.add(
3124        filterValues[i]
3125      );
3126    }
3127    forAllUserDate0 (
3128      operator,
3129      arrayAsList
3130    );
3131  }
3132
3133  public void thereExistsUserDate0 (
3134    short operator,
3135    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3136  ) {
3137    java.util.List   arrayAsList = new java.util.ArrayList  ();
3138    for(int i = 0; i < filterValues.length; i++) {
3139      arrayAsList.add(
3140        filterValues[i]
3141      );
3142    }
3143    thereExistsUserDate0 (
3144      operator,
3145      arrayAsList
3146    );
3147  }
3148
3149  public void orderByUserDate0 (
3150    short order
3151  ) {
3152    refAddValue(
3153      "org:opencrx:kernel:generic:CrxObject:userDate0",
3154      order
3155    );
3156  }
3157      
3158// ----------------------------------------------------------------------------
3159// Filter/ImplAttributeIsNotStruct
3160// ----------------------------------------------------------------------------
3161  public void forAllUserDate1 (
3162    short operator,
3163    java.util.Collection   values
3164  ) {
3165    refAddValue(
3166      "org:opencrx:kernel:generic:CrxObject:userDate1",
3167      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3168      operator,
3169      values
3170    );
3171  }
3172
3173  public void thereExistsUserDate1 (
3174    short operator,
3175    java.util.Collection   values
3176  ) {
3177    refAddValue(
3178      "org:opencrx:kernel:generic:CrxObject:userDate1",
3179      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3180      operator,
3181      values
3182    );
3183  }
3184
3185  public void forAllUserDate1 (
3186    short operator,
3187    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3188  ) {
3189    java.util.List   arrayAsList = new java.util.ArrayList  ();
3190    for(int i = 0; i < filterValues.length; i++) {
3191      arrayAsList.add(
3192        filterValues[i]
3193      );
3194    }
3195    forAllUserDate1 (
3196      operator,
3197      arrayAsList
3198    );
3199  }
3200
3201  public void thereExistsUserDate1 (
3202    short operator,
3203    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3204  ) {
3205    java.util.List   arrayAsList = new java.util.ArrayList  ();
3206    for(int i = 0; i < filterValues.length; i++) {
3207      arrayAsList.add(
3208        filterValues[i]
3209      );
3210    }
3211    thereExistsUserDate1 (
3212      operator,
3213      arrayAsList
3214    );
3215  }
3216
3217  public void orderByUserDate1 (
3218    short order
3219  ) {
3220    refAddValue(
3221      "org:opencrx:kernel:generic:CrxObject:userDate1",
3222      order
3223    );
3224  }
3225      
3226// ----------------------------------------------------------------------------
3227// Filter/ImplAttributeIsNotStruct
3228// ----------------------------------------------------------------------------
3229  public void forAllUserDate2 (
3230    short operator,
3231    java.util.Collection   values
3232  ) {
3233    refAddValue(
3234      "org:opencrx:kernel:generic:CrxObject:userDate2",
3235      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3236      operator,
3237      values
3238    );
3239  }
3240
3241  public void thereExistsUserDate2 (
3242    short operator,
3243    java.util.Collection   values
3244  ) {
3245    refAddValue(
3246      "org:opencrx:kernel:generic:CrxObject:userDate2",
3247      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3248      operator,
3249      values
3250    );
3251  }
3252
3253  public void forAllUserDate2 (
3254    short operator,
3255    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3256  ) {
3257    java.util.List   arrayAsList = new java.util.ArrayList  ();
3258    for(int i = 0; i < filterValues.length; i++) {
3259      arrayAsList.add(
3260        filterValues[i]
3261      );
3262    }
3263    forAllUserDate2 (
3264      operator,
3265      arrayAsList
3266    );
3267  }
3268
3269  public void thereExistsUserDate2 (
3270    short operator,
3271    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3272  ) {
3273    java.util.List   arrayAsList = new java.util.ArrayList  ();
3274    for(int i = 0; i < filterValues.length; i++) {
3275      arrayAsList.add(
3276        filterValues[i]
3277      );
3278    }
3279    thereExistsUserDate2 (
3280      operator,
3281      arrayAsList
3282    );
3283  }
3284
3285  public void orderByUserDate2 (
3286    short order
3287  ) {
3288    refAddValue(
3289      "org:opencrx:kernel:generic:CrxObject:userDate2",
3290      order
3291    );
3292  }
3293      
3294// ----------------------------------------------------------------------------
3295// Filter/ImplAttributeIsNotStruct
3296// ----------------------------------------------------------------------------
3297  public void forAllUserDate3 (
3298    short operator,
3299    java.util.Collection   values
3300  ) {
3301    refAddValue(
3302      "org:opencrx:kernel:generic:CrxObject:userDate3",
3303      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3304      operator,
3305      values
3306    );
3307  }
3308
3309  public void thereExistsUserDate3 (
3310    short operator,
3311    java.util.Collection   values
3312  ) {
3313    refAddValue(
3314      "org:opencrx:kernel:generic:CrxObject:userDate3",
3315      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3316      operator,
3317      values
3318    );
3319  }
3320
3321  public void forAllUserDate3 (
3322    short operator,
3323    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3324  ) {
3325    java.util.List   arrayAsList = new java.util.ArrayList  ();
3326    for(int i = 0; i < filterValues.length; i++) {
3327      arrayAsList.add(
3328        filterValues[i]
3329      );
3330    }
3331    forAllUserDate3 (
3332      operator,
3333      arrayAsList
3334    );
3335  }
3336
3337  public void thereExistsUserDate3 (
3338    short operator,
3339    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3340  ) {
3341    java.util.List   arrayAsList = new java.util.ArrayList  ();
3342    for(int i = 0; i < filterValues.length; i++) {
3343      arrayAsList.add(
3344        filterValues[i]
3345      );
3346    }
3347    thereExistsUserDate3 (
3348      operator,
3349      arrayAsList
3350    );
3351  }
3352
3353  public void orderByUserDate3 (
3354    short order
3355  ) {
3356    refAddValue(
3357      "org:opencrx:kernel:generic:CrxObject:userDate3",
3358      order
3359    );
3360  }
3361      
3362// ----------------------------------------------------------------------------
3363// Filter/ImplAttributeIsNotStruct
3364// ----------------------------------------------------------------------------
3365  public void forAllUserDate4 (
3366    short operator,
3367    java.util.Collection   values
3368  ) {
3369    refAddValue(
3370      "org:opencrx:kernel:generic:CrxObject:userDate4",
3371      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3372      operator,
3373      values
3374    );
3375  }
3376
3377  public void thereExistsUserDate4 (
3378    short operator,
3379    java.util.Collection   values
3380  ) {
3381    refAddValue(
3382      "org:opencrx:kernel:generic:CrxObject:userDate4",
3383      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3384      operator,
3385      values
3386    );
3387  }
3388
3389  public void forAllUserDate4 (
3390    short operator,
3391    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3392  ) {
3393    java.util.List   arrayAsList = new java.util.ArrayList  ();
3394    for(int i = 0; i < filterValues.length; i++) {
3395      arrayAsList.add(
3396        filterValues[i]
3397      );
3398    }
3399    forAllUserDate4 (
3400      operator,
3401      arrayAsList
3402    );
3403  }
3404
3405  public void thereExistsUserDate4 (
3406    short operator,
3407    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3408  ) {
3409    java.util.List   arrayAsList = new java.util.ArrayList  ();
3410    for(int i = 0; i < filterValues.length; i++) {
3411      arrayAsList.add(
3412        filterValues[i]
3413      );
3414    }
3415    thereExistsUserDate4 (
3416      operator,
3417      arrayAsList
3418    );
3419  }
3420
3421  public void orderByUserDate4 (
3422    short order
3423  ) {
3424    refAddValue(
3425      "org:opencrx:kernel:generic:CrxObject:userDate4",
3426      order
3427    );
3428  }
3429      
3430// ----------------------------------------------------------------------------
3431// Filter/ImplAttributeIsNotStruct
3432// ----------------------------------------------------------------------------
3433  public void forAllUserDateTime0 (
3434    short operator,
3435    java.util.Collection   values
3436  ) {
3437    refAddValue(
3438      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3439      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3440      operator,
3441      values
3442    );
3443  }
3444
3445  public void thereExistsUserDateTime0 (
3446    short operator,
3447    java.util.Collection   values
3448  ) {
3449    refAddValue(
3450      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3451      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3452      operator,
3453      values
3454    );
3455  }
3456
3457  public void forAllUserDateTime0 (
3458    short operator,
3459    java.util.Date  [] filterValues
3460  ) {
3461    java.util.List   arrayAsList = new java.util.ArrayList  ();
3462    for(int i = 0; i < filterValues.length; i++) {
3463      arrayAsList.add(
3464        filterValues[i]
3465      );
3466    }
3467    forAllUserDateTime0 (
3468      operator,
3469      arrayAsList
3470    );
3471  }
3472
3473  public void thereExistsUserDateTime0 (
3474    short operator,
3475    java.util.Date  [] filterValues
3476  ) {
3477    java.util.List   arrayAsList = new java.util.ArrayList  ();
3478    for(int i = 0; i < filterValues.length; i++) {
3479      arrayAsList.add(
3480        filterValues[i]
3481      );
3482    }
3483    thereExistsUserDateTime0 (
3484      operator,
3485      arrayAsList
3486    );
3487  }
3488
3489  public void orderByUserDateTime0 (
3490    short order
3491  ) {
3492    refAddValue(
3493      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3494      order
3495    );
3496  }
3497      
3498// ----------------------------------------------------------------------------
3499// Filter/ImplAttributeIsNotStruct
3500// ----------------------------------------------------------------------------
3501  public void forAllUserDateTime1 (
3502    short operator,
3503    java.util.Collection   values
3504  ) {
3505    refAddValue(
3506      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3507      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3508      operator,
3509      values
3510    );
3511  }
3512
3513  public void thereExistsUserDateTime1 (
3514    short operator,
3515    java.util.Collection   values
3516  ) {
3517    refAddValue(
3518      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3519      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3520      operator,
3521      values
3522    );
3523  }
3524
3525  public void forAllUserDateTime1 (
3526    short operator,
3527    java.util.Date  [] filterValues
3528  ) {
3529    java.util.List   arrayAsList = new java.util.ArrayList  ();
3530    for(int i = 0; i < filterValues.length; i++) {
3531      arrayAsList.add(
3532        filterValues[i]
3533      );
3534    }
3535    forAllUserDateTime1 (
3536      operator,
3537      arrayAsList
3538    );
3539  }
3540
3541  public void thereExistsUserDateTime1 (
3542    short operator,
3543    java.util.Date  [] filterValues
3544  ) {
3545    java.util.List   arrayAsList = new java.util.ArrayList  ();
3546    for(int i = 0; i < filterValues.length; i++) {
3547      arrayAsList.add(
3548        filterValues[i]
3549      );
3550    }
3551    thereExistsUserDateTime1 (
3552      operator,
3553      arrayAsList
3554    );
3555  }
3556
3557  public void orderByUserDateTime1 (
3558    short order
3559  ) {
3560    refAddValue(
3561      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3562      order
3563    );
3564  }
3565      
3566// ----------------------------------------------------------------------------
3567// Filter/ImplAttributeIsNotStruct
3568// ----------------------------------------------------------------------------
3569  public void forAllUserDateTime2 (
3570    short operator,
3571    java.util.Collection   values
3572  ) {
3573    refAddValue(
3574      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3575      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3576      operator,
3577      values
3578    );
3579  }
3580
3581  public void thereExistsUserDateTime2 (
3582    short operator,
3583    java.util.Collection   values
3584  ) {
3585    refAddValue(
3586      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3587      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3588      operator,
3589      values
3590    );
3591  }
3592
3593  public void forAllUserDateTime2 (
3594    short operator,
3595    java.util.Date  [] filterValues
3596  ) {
3597    java.util.List   arrayAsList = new java.util.ArrayList  ();
3598    for(int i = 0; i < filterValues.length; i++) {
3599      arrayAsList.add(
3600        filterValues[i]
3601      );
3602    }
3603    forAllUserDateTime2 (
3604      operator,
3605      arrayAsList
3606    );
3607  }
3608
3609  public void thereExistsUserDateTime2 (
3610    short operator,
3611    java.util.Date  [] filterValues
3612  ) {
3613    java.util.List   arrayAsList = new java.util.ArrayList  ();
3614    for(int i = 0; i < filterValues.length; i++) {
3615      arrayAsList.add(
3616        filterValues[i]
3617      );
3618    }
3619    thereExistsUserDateTime2 (
3620      operator,
3621      arrayAsList
3622    );
3623  }
3624
3625  public void orderByUserDateTime2 (
3626    short order
3627  ) {
3628    refAddValue(
3629      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3630      order
3631    );
3632  }
3633      
3634// ----------------------------------------------------------------------------
3635// Filter/ImplAttributeIsNotStruct
3636// ----------------------------------------------------------------------------
3637  public void forAllUserDateTime3 (
3638    short operator,
3639    java.util.Collection   values
3640  ) {
3641    refAddValue(
3642      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3643      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3644      operator,
3645      values
3646    );
3647  }
3648
3649  public void thereExistsUserDateTime3 (
3650    short operator,
3651    java.util.Collection   values
3652  ) {
3653    refAddValue(
3654      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3655      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3656      operator,
3657      values
3658    );
3659  }
3660
3661  public void forAllUserDateTime3 (
3662    short operator,
3663    java.util.Date  [] filterValues
3664  ) {
3665    java.util.List   arrayAsList = new java.util.ArrayList  ();
3666    for(int i = 0; i < filterValues.length; i++) {
3667      arrayAsList.add(
3668        filterValues[i]
3669      );
3670    }
3671    forAllUserDateTime3 (
3672      operator,
3673      arrayAsList
3674    );
3675  }
3676
3677  public void thereExistsUserDateTime3 (
3678    short operator,
3679    java.util.Date  [] filterValues
3680  ) {
3681    java.util.List   arrayAsList = new java.util.ArrayList  ();
3682    for(int i = 0; i < filterValues.length; i++) {
3683      arrayAsList.add(
3684        filterValues[i]
3685      );
3686    }
3687    thereExistsUserDateTime3 (
3688      operator,
3689      arrayAsList
3690    );
3691  }
3692
3693  public void orderByUserDateTime3 (
3694    short order
3695  ) {
3696    refAddValue(
3697      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3698      order
3699    );
3700  }
3701      
3702// ----------------------------------------------------------------------------
3703// Filter/ImplAttributeIsNotStruct
3704// ----------------------------------------------------------------------------
3705  public void forAllUserDateTime4 (
3706    short operator,
3707    java.util.Collection   values
3708  ) {
3709    refAddValue(
3710      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3711      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3712      operator,
3713      values
3714    );
3715  }
3716
3717  public void thereExistsUserDateTime4 (
3718    short operator,
3719    java.util.Collection   values
3720  ) {
3721    refAddValue(
3722      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3723      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3724      operator,
3725      values
3726    );
3727  }
3728
3729  public void forAllUserDateTime4 (
3730    short operator,
3731    java.util.Date  [] filterValues
3732  ) {
3733    java.util.List   arrayAsList = new java.util.ArrayList  ();
3734    for(int i = 0; i < filterValues.length; i++) {
3735      arrayAsList.add(
3736        filterValues[i]
3737      );
3738    }
3739    forAllUserDateTime4 (
3740      operator,
3741      arrayAsList
3742    );
3743  }
3744
3745  public void thereExistsUserDateTime4 (
3746    short operator,
3747    java.util.Date  [] filterValues
3748  ) {
3749    java.util.List   arrayAsList = new java.util.ArrayList  ();
3750    for(int i = 0; i < filterValues.length; i++) {
3751      arrayAsList.add(
3752        filterValues[i]
3753      );
3754    }
3755    thereExistsUserDateTime4 (
3756      operator,
3757      arrayAsList
3758    );
3759  }
3760
3761  public void orderByUserDateTime4 (
3762    short order
3763  ) {
3764    refAddValue(
3765      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3766      order
3767    );
3768  }
3769      
3770// ----------------------------------------------------------------------------
3771// Filter/ImplAttributeIsNotStruct
3772// ----------------------------------------------------------------------------
3773  public void forAllUserNumber0 (
3774    short operator,
3775    java.util.Collection   values
3776  ) {
3777    refAddValue(
3778      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3779      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3780      operator,
3781      values
3782    );
3783  }
3784
3785  public void thereExistsUserNumber0 (
3786    short operator,
3787    java.util.Collection   values
3788  ) {
3789    refAddValue(
3790      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3791      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3792      operator,
3793      values
3794    );
3795  }
3796
3797  public void forAllUserNumber0 (
3798    short operator,
3799    java.math.BigDecimal  [] filterValues
3800  ) {
3801    java.util.List   arrayAsList = new java.util.ArrayList  ();
3802    for(int i = 0; i < filterValues.length; i++) {
3803      arrayAsList.add(
3804        filterValues[i]
3805      );
3806    }
3807    forAllUserNumber0 (
3808      operator,
3809      arrayAsList
3810    );
3811  }
3812
3813  public void thereExistsUserNumber0 (
3814    short operator,
3815    java.math.BigDecimal  [] filterValues
3816  ) {
3817    java.util.List   arrayAsList = new java.util.ArrayList  ();
3818    for(int i = 0; i < filterValues.length; i++) {
3819      arrayAsList.add(
3820        filterValues[i]
3821      );
3822    }
3823    thereExistsUserNumber0 (
3824      operator,
3825      arrayAsList
3826    );
3827  }
3828
3829  public void orderByUserNumber0 (
3830    short order
3831  ) {
3832    refAddValue(
3833      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3834      order
3835    );
3836  }
3837      
3838// ----------------------------------------------------------------------------
3839// Filter/ImplAttributeIsNotStruct
3840// ----------------------------------------------------------------------------
3841  public void forAllUserNumber1 (
3842    short operator,
3843    java.util.Collection   values
3844  ) {
3845    refAddValue(
3846      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3847      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3848      operator,
3849      values
3850    );
3851  }
3852
3853  public void thereExistsUserNumber1 (
3854    short operator,
3855    java.util.Collection   values
3856  ) {
3857    refAddValue(
3858      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3859      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3860      operator,
3861      values
3862    );
3863  }
3864
3865  public void forAllUserNumber1 (
3866    short operator,
3867    java.math.BigDecimal  [] filterValues
3868  ) {
3869    java.util.List   arrayAsList = new java.util.ArrayList  ();
3870    for(int i = 0; i < filterValues.length; i++) {
3871      arrayAsList.add(
3872        filterValues[i]
3873      );
3874    }
3875    forAllUserNumber1 (
3876      operator,
3877      arrayAsList
3878    );
3879  }
3880
3881  public void thereExistsUserNumber1 (
3882    short operator,
3883    java.math.BigDecimal  [] filterValues
3884  ) {
3885    java.util.List   arrayAsList = new java.util.ArrayList  ();
3886    for(int i = 0; i < filterValues.length; i++) {
3887      arrayAsList.add(
3888        filterValues[i]
3889      );
3890    }
3891    thereExistsUserNumber1 (
3892      operator,
3893      arrayAsList
3894    );
3895  }
3896
3897  public void orderByUserNumber1 (
3898    short order
3899  ) {
3900    refAddValue(
3901      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3902      order
3903    );
3904  }
3905      
3906// ----------------------------------------------------------------------------
3907// Filter/ImplAttributeIsNotStruct
3908// ----------------------------------------------------------------------------
3909  public void forAllUserNumber2 (
3910    short operator,
3911    java.util.Collection   values
3912  ) {
3913    refAddValue(
3914      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3915      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3916      operator,
3917      values
3918    );
3919  }
3920
3921  public void thereExistsUserNumber2 (
3922    short operator,
3923    java.util.Collection   values
3924  ) {
3925    refAddValue(
3926      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3927      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3928      operator,
3929      values
3930    );
3931  }
3932
3933  public void forAllUserNumber2 (
3934    short operator,
3935    java.math.BigDecimal  [] filterValues
3936  ) {
3937    java.util.List   arrayAsList = new java.util.ArrayList  ();
3938    for(int i = 0; i < filterValues.length; i++) {
3939      arrayAsList.add(
3940        filterValues[i]
3941      );
3942    }
3943    forAllUserNumber2 (
3944      operator,
3945      arrayAsList
3946    );
3947  }
3948
3949  public void thereExistsUserNumber2 (
3950    short operator,
3951    java.math.BigDecimal  [] filterValues
3952  ) {
3953    java.util.List   arrayAsList = new java.util.ArrayList  ();
3954    for(int i = 0; i < filterValues.length; i++) {
3955      arrayAsList.add(
3956        filterValues[i]
3957      );
3958    }
3959    thereExistsUserNumber2 (
3960      operator,
3961      arrayAsList
3962    );
3963  }
3964
3965  public void orderByUserNumber2 (
3966    short order
3967  ) {
3968    refAddValue(
3969      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3970      order
3971    );
3972  }
3973      
3974// ----------------------------------------------------------------------------
3975// Filter/ImplAttributeIsNotStruct
3976// ----------------------------------------------------------------------------
3977  public void forAllUserNumber3 (
3978    short operator,
3979    java.util.Collection   values
3980  ) {
3981    refAddValue(
3982      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3983      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3984      operator,
3985      values
3986    );
3987  }
3988
3989  public void thereExistsUserNumber3 (
3990    short operator,
3991    java.util.Collection   values
3992  ) {
3993    refAddValue(
3994      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3995      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3996      operator,
3997      values
3998    );
3999  }
4000
4001  public void forAllUserNumber3 (
4002    short operator,
4003    java.math.BigDecimal  [] filterValues
4004  ) {
4005    java.util.List   arrayAsList = new java.util.ArrayList  ();
4006    for(int i = 0; i < filterValues.length; i++) {
4007      arrayAsList.add(
4008        filterValues[i]
4009      );
4010    }
4011    forAllUserNumber3 (
4012      operator,
4013      arrayAsList
4014    );
4015  }
4016
4017  public void thereExistsUserNumber3 (
4018    short operator,
4019    java.math.BigDecimal  [] filterValues
4020  ) {
4021    java.util.List   arrayAsList = new java.util.ArrayList  ();
4022    for(int i = 0; i < filterValues.length; i++) {
4023      arrayAsList.add(
4024        filterValues[i]
4025      );
4026    }
4027    thereExistsUserNumber3 (
4028      operator,
4029      arrayAsList
4030    );
4031  }
4032
4033  public void orderByUserNumber3 (
4034    short order
4035  ) {
4036    refAddValue(
4037      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4038      order
4039    );
4040  }
4041      
4042// ----------------------------------------------------------------------------
4043// Filter/ImplAttributeIsNotStruct
4044// ----------------------------------------------------------------------------
4045  public void forAllUserNumber4 (
4046    short operator,
4047    java.util.Collection   values
4048  ) {
4049    refAddValue(
4050      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4051      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4052      operator,
4053      values
4054    );
4055  }
4056
4057  public void thereExistsUserNumber4 (
4058    short operator,
4059    java.util.Collection   values
4060  ) {
4061    refAddValue(
4062      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4063      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4064      operator,
4065      values
4066    );
4067  }
4068
4069  public void forAllUserNumber4 (
4070    short operator,
4071    java.math.BigDecimal  [] filterValues
4072  ) {
4073    java.util.List   arrayAsList = new java.util.ArrayList  ();
4074    for(int i = 0; i < filterValues.length; i++) {
4075      arrayAsList.add(
4076        filterValues[i]
4077      );
4078    }
4079    forAllUserNumber4 (
4080      operator,
4081      arrayAsList
4082    );
4083  }
4084
4085  public void thereExistsUserNumber4 (
4086    short operator,
4087    java.math.BigDecimal  [] filterValues
4088  ) {
4089    java.util.List   arrayAsList = new java.util.ArrayList  ();
4090    for(int i = 0; i < filterValues.length; i++) {
4091      arrayAsList.add(
4092        filterValues[i]
4093      );
4094    }
4095    thereExistsUserNumber4 (
4096      operator,
4097      arrayAsList
4098    );
4099  }
4100
4101  public void orderByUserNumber4 (
4102    short order
4103  ) {
4104    refAddValue(
4105      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4106      order
4107    );
4108  }
4109      
4110// ----------------------------------------------------------------------------
4111// Filter/ImplAttributeIsNotStruct
4112// ----------------------------------------------------------------------------
4113  public void forAllUserString0 (
4114    short operator,
4115    java.util.Collection   values
4116  ) {
4117    refAddValue(
4118      "org:opencrx:kernel:generic:CrxObject:userString0",
4119      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4120      operator,
4121      values
4122    );
4123  }
4124
4125  public void thereExistsUserString0 (
4126    short operator,
4127    java.util.Collection   values
4128  ) {
4129    refAddValue(
4130      "org:opencrx:kernel:generic:CrxObject:userString0",
4131      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4132      operator,
4133      values
4134    );
4135  }
4136
4137  public void forAllUserString0 (
4138    short operator,
4139    String  [] filterValues
4140  ) {
4141    java.util.List   arrayAsList = new java.util.ArrayList  ();
4142    for(int i = 0; i < filterValues.length; i++) {
4143      arrayAsList.add(
4144        filterValues[i]
4145      );
4146    }
4147    forAllUserString0 (
4148      operator,
4149      arrayAsList
4150    );
4151  }
4152
4153  public void thereExistsUserString0 (
4154    short operator,
4155    String  [] filterValues
4156  ) {
4157    java.util.List   arrayAsList = new java.util.ArrayList  ();
4158    for(int i = 0; i < filterValues.length; i++) {
4159      arrayAsList.add(
4160        filterValues[i]
4161      );
4162    }
4163    thereExistsUserString0 (
4164      operator,
4165      arrayAsList
4166    );
4167  }
4168
4169  public void orderByUserString0 (
4170    short order
4171  ) {
4172    refAddValue(
4173      "org:opencrx:kernel:generic:CrxObject:userString0",
4174      order
4175    );
4176  }
4177      
4178// ----------------------------------------------------------------------------
4179// Filter/ImplAttributeIsNotStruct
4180// ----------------------------------------------------------------------------
4181  public void forAllUserString1 (
4182    short operator,
4183    java.util.Collection   values
4184  ) {
4185    refAddValue(
4186      "org:opencrx:kernel:generic:CrxObject:userString1",
4187      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4188      operator,
4189      values
4190    );
4191  }
4192
4193  public void thereExistsUserString1 (
4194    short operator,
4195    java.util.Collection   values
4196  ) {
4197    refAddValue(
4198      "org:opencrx:kernel:generic:CrxObject:userString1",
4199      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4200      operator,
4201      values
4202    );
4203  }
4204
4205  public void forAllUserString1 (
4206    short operator,
4207    String  [] filterValues
4208  ) {
4209    java.util.List   arrayAsList = new java.util.ArrayList  ();
4210    for(int i = 0; i < filterValues.length; i++) {
4211      arrayAsList.add(
4212        filterValues[i]
4213      );
4214    }
4215    forAllUserString1 (
4216      operator,
4217      arrayAsList
4218    );
4219  }
4220
4221  public void thereExistsUserString1 (
4222    short operator,
4223    String  [] filterValues
4224  ) {
4225    java.util.List   arrayAsList = new java.util.ArrayList  ();
4226    for(int i = 0; i < filterValues.length; i++) {
4227      arrayAsList.add(
4228        filterValues[i]
4229      );
4230    }
4231    thereExistsUserString1 (
4232      operator,
4233      arrayAsList
4234    );
4235  }
4236
4237  public void orderByUserString1 (
4238    short order
4239  ) {
4240    refAddValue(
4241      "org:opencrx:kernel:generic:CrxObject:userString1",
4242      order
4243    );
4244  }
4245      
4246// ----------------------------------------------------------------------------
4247// Filter/ImplAttributeIsNotStruct
4248// ----------------------------------------------------------------------------
4249  public void forAllUserString2 (
4250    short operator,
4251    java.util.Collection   values
4252  ) {
4253    refAddValue(
4254      "org:opencrx:kernel:generic:CrxObject:userString2",
4255      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4256      operator,
4257      values
4258    );
4259  }
4260
4261  public void thereExistsUserString2 (
4262    short operator,
4263    java.util.Collection   values
4264  ) {
4265    refAddValue(
4266      "org:opencrx:kernel:generic:CrxObject:userString2",
4267      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4268      operator,
4269      values
4270    );
4271  }
4272
4273  public void forAllUserString2 (
4274    short operator,
4275    String  [] filterValues
4276  ) {
4277    java.util.List   arrayAsList = new java.util.ArrayList  ();
4278    for(int i = 0; i < filterValues.length; i++) {
4279      arrayAsList.add(
4280        filterValues[i]
4281      );
4282    }
4283    forAllUserString2 (
4284      operator,
4285      arrayAsList
4286    );
4287  }
4288
4289  public void thereExistsUserString2 (
4290    short operator,
4291    String  [] filterValues
4292  ) {
4293    java.util.List   arrayAsList = new java.util.ArrayList  ();
4294    for(int i = 0; i < filterValues.length; i++) {
4295      arrayAsList.add(
4296        filterValues[i]
4297      );
4298    }
4299    thereExistsUserString2 (
4300      operator,
4301      arrayAsList
4302    );
4303  }
4304
4305  public void orderByUserString2 (
4306    short order
4307  ) {
4308    refAddValue(
4309      "org:opencrx:kernel:generic:CrxObject:userString2",
4310      order
4311    );
4312  }
4313      
4314// ----------------------------------------------------------------------------
4315// Filter/ImplAttributeIsNotStruct
4316// ----------------------------------------------------------------------------
4317  public void forAllUserString3 (
4318    short operator,
4319    java.util.Collection   values
4320  ) {
4321    refAddValue(
4322      "org:opencrx:kernel:generic:CrxObject:userString3",
4323      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4324      operator,
4325      values
4326    );
4327  }
4328
4329  public void thereExistsUserString3 (
4330    short operator,
4331    java.util.Collection   values
4332  ) {
4333    refAddValue(
4334      "org:opencrx:kernel:generic:CrxObject:userString3",
4335      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4336      operator,
4337      values
4338    );
4339  }
4340
4341  public void forAllUserString3 (
4342    short operator,
4343    String  [] filterValues
4344  ) {
4345    java.util.List   arrayAsList = new java.util.ArrayList  ();
4346    for(int i = 0; i < filterValues.length; i++) {
4347      arrayAsList.add(
4348        filterValues[i]
4349      );
4350    }
4351    forAllUserString3 (
4352      operator,
4353      arrayAsList
4354    );
4355  }
4356
4357  public void thereExistsUserString3 (
4358    short operator,
4359    String  [] filterValues
4360  ) {
4361    java.util.List   arrayAsList = new java.util.ArrayList  ();
4362    for(int i = 0; i < filterValues.length; i++) {
4363      arrayAsList.add(
4364        filterValues[i]
4365      );
4366    }
4367    thereExistsUserString3 (
4368      operator,
4369      arrayAsList
4370    );
4371  }
4372
4373  public void orderByUserString3 (
4374    short order
4375  ) {
4376    refAddValue(
4377      "org:opencrx:kernel:generic:CrxObject:userString3",
4378      order
4379    );
4380  }
4381      
4382// ----------------------------------------------------------------------------
4383// Filter/ImplAttributeIsNotStruct
4384// ----------------------------------------------------------------------------
4385  public void forAllUserString4 (
4386    short operator,
4387    java.util.Collection   values
4388  ) {
4389    refAddValue(
4390      "org:opencrx:kernel:generic:CrxObject:userString4",
4391      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4392      operator,
4393      values
4394    );
4395  }
4396
4397  public void thereExistsUserString4 (
4398    short operator,
4399    java.util.Collection   values
4400  ) {
4401    refAddValue(
4402      "org:opencrx:kernel:generic:CrxObject:userString4",
4403      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4404      operator,
4405      values
4406    );
4407  }
4408
4409  public void forAllUserString4 (
4410    short operator,
4411    String  [] filterValues
4412  ) {
4413    java.util.List   arrayAsList = new java.util.ArrayList  ();
4414    for(int i = 0; i < filterValues.length; i++) {
4415      arrayAsList.add(
4416        filterValues[i]
4417      );
4418    }
4419    forAllUserString4 (
4420      operator,
4421      arrayAsList
4422    );
4423  }
4424
4425  public void thereExistsUserString4 (
4426    short operator,
4427    String  [] filterValues
4428  ) {
4429    java.util.List   arrayAsList = new java.util.ArrayList  ();
4430    for(int i = 0; i < filterValues.length; i++) {
4431      arrayAsList.add(
4432        filterValues[i]
4433      );
4434    }
4435    thereExistsUserString4 (
4436      operator,
4437      arrayAsList
4438    );
4439  }
4440
4441  public void orderByUserString4 (
4442    short order
4443  ) {
4444    refAddValue(
4445      "org:opencrx:kernel:generic:CrxObject:userString4",
4446      order
4447    );
4448  }
4449      
4450// ----------------------------------------------------------------------------
4451// Filter/ImplAttributeIsNotStruct
4452// ----------------------------------------------------------------------------
4453  public void forAllCreatedAt (
4454    short operator,
4455    java.util.Collection   values
4456  ) {
4457    refAddValue(
4458      "org:openmdx:base:BasicObject:createdAt",
4459      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4460      operator,
4461      values
4462    );
4463  }
4464
4465  public void thereExistsCreatedAt (
4466    short operator,
4467    java.util.Collection   values
4468  ) {
4469    refAddValue(
4470      "org:openmdx:base:BasicObject:createdAt",
4471      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4472      operator,
4473      values
4474    );
4475  }
4476
4477  public void forAllCreatedAt (
4478    short operator,
4479    java.util.Date  [] filterValues
4480  ) {
4481    java.util.List   arrayAsList = new java.util.ArrayList  ();
4482    for(int i = 0; i < filterValues.length; i++) {
4483      arrayAsList.add(
4484        filterValues[i]
4485      );
4486    }
4487    forAllCreatedAt (
4488      operator,
4489      arrayAsList
4490    );
4491  }
4492
4493  public void thereExistsCreatedAt (
4494    short operator,
4495    java.util.Date  [] filterValues
4496  ) {
4497    java.util.List   arrayAsList = new java.util.ArrayList  ();
4498    for(int i = 0; i < filterValues.length; i++) {
4499      arrayAsList.add(
4500        filterValues[i]
4501      );
4502    }
4503    thereExistsCreatedAt (
4504      operator,
4505      arrayAsList
4506    );
4507  }
4508
4509  public void orderByCreatedAt (
4510    short order
4511  ) {
4512    refAddValue(
4513      "org:openmdx:base:BasicObject:createdAt",
4514      order
4515    );
4516  }
4517      
4518// ----------------------------------------------------------------------------
4519// Filter/ImplAttributeIsNotStruct
4520// ----------------------------------------------------------------------------
4521  public void forAllCreatedBy (
4522    short operator,
4523    java.util.Collection   values
4524  ) {
4525    refAddValue(
4526      "org:openmdx:base:BasicObject:createdBy",
4527      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4528      operator,
4529      values
4530    );
4531  }
4532
4533  public void thereExistsCreatedBy (
4534    short operator,
4535    java.util.Collection   values
4536  ) {
4537    refAddValue(
4538      "org:openmdx:base:BasicObject:createdBy",
4539      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4540      operator,
4541      values
4542    );
4543  }
4544
4545  public void forAllCreatedBy (
4546    short operator,
4547    String  [] filterValues
4548  ) {
4549    java.util.List   arrayAsList = new java.util.ArrayList  ();
4550    for(int i = 0; i < filterValues.length; i++) {
4551      arrayAsList.add(
4552        filterValues[i]
4553      );
4554    }
4555    forAllCreatedBy (
4556      operator,
4557      arrayAsList
4558    );
4559  }
4560
4561  public void thereExistsCreatedBy (
4562    short operator,
4563    String  [] filterValues
4564  ) {
4565    java.util.List   arrayAsList = new java.util.ArrayList  ();
4566    for(int i = 0; i < filterValues.length; i++) {
4567      arrayAsList.add(
4568        filterValues[i]
4569      );
4570    }
4571    thereExistsCreatedBy (
4572      operator,
4573      arrayAsList
4574    );
4575  }
4576
4577  public void orderByCreatedBy (
4578    short order
4579  ) {
4580    refAddValue(
4581      "org:openmdx:base:BasicObject:createdBy",
4582      order
4583    );
4584  }
4585      
4586// ----------------------------------------------------------------------------
4587// Filter/ImplAttributeIsNotStruct
4588// ----------------------------------------------------------------------------
4589  public void forAllModifiedAt (
4590    short operator,
4591    java.util.Collection   values
4592  ) {
4593    refAddValue(
4594      "org:openmdx:base:BasicObject:modifiedAt",
4595      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4596      operator,
4597      values
4598    );
4599  }
4600
4601  public void thereExistsModifiedAt (
4602    short operator,
4603    java.util.Collection   values
4604  ) {
4605    refAddValue(
4606      "org:openmdx:base:BasicObject:modifiedAt",
4607      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4608      operator,
4609      values
4610    );
4611  }
4612
4613  public void forAllModifiedAt (
4614    short operator,
4615    java.util.Date  [] filterValues
4616  ) {
4617    java.util.List   arrayAsList = new java.util.ArrayList  ();
4618    for(int i = 0; i < filterValues.length; i++) {
4619      arrayAsList.add(
4620        filterValues[i]
4621      );
4622    }
4623    forAllModifiedAt (
4624      operator,
4625      arrayAsList
4626    );
4627  }
4628
4629  public void thereExistsModifiedAt (
4630    short operator,
4631    java.util.Date  [] filterValues
4632  ) {
4633    java.util.List   arrayAsList = new java.util.ArrayList  ();
4634    for(int i = 0; i < filterValues.length; i++) {
4635      arrayAsList.add(
4636        filterValues[i]
4637      );
4638    }
4639    thereExistsModifiedAt (
4640      operator,
4641      arrayAsList
4642    );
4643  }
4644
4645  public void orderByModifiedAt (
4646    short order
4647  ) {
4648    refAddValue(
4649      "org:openmdx:base:BasicObject:modifiedAt",
4650      order
4651    );
4652  }
4653      
4654// ----------------------------------------------------------------------------
4655// Filter/ImplAttributeIsNotStruct
4656// ----------------------------------------------------------------------------
4657  public void forAllModifiedBy (
4658    short operator,
4659    java.util.Collection   values
4660  ) {
4661    refAddValue(
4662      "org:openmdx:base:BasicObject:modifiedBy",
4663      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4664      operator,
4665      values
4666    );
4667  }
4668
4669  public void thereExistsModifiedBy (
4670    short operator,
4671    java.util.Collection   values
4672  ) {
4673    refAddValue(
4674      "org:openmdx:base:BasicObject:modifiedBy",
4675      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4676      operator,
4677      values
4678    );
4679  }
4680
4681  public void forAllModifiedBy (
4682    short operator,
4683    String  [] filterValues
4684  ) {
4685    java.util.List   arrayAsList = new java.util.ArrayList  ();
4686    for(int i = 0; i < filterValues.length; i++) {
4687      arrayAsList.add(
4688        filterValues[i]
4689      );
4690    }
4691    forAllModifiedBy (
4692      operator,
4693      arrayAsList
4694    );
4695  }
4696
4697  public void thereExistsModifiedBy (
4698    short operator,
4699    String  [] filterValues
4700  ) {
4701    java.util.List   arrayAsList = new java.util.ArrayList  ();
4702    for(int i = 0; i < filterValues.length; i++) {
4703      arrayAsList.add(
4704        filterValues[i]
4705      );
4706    }
4707    thereExistsModifiedBy (
4708      operator,
4709      arrayAsList
4710    );
4711  }
4712
4713  public void orderByModifiedBy (
4714    short order
4715  ) {
4716    refAddValue(
4717      "org:openmdx:base:BasicObject:modifiedBy",
4718      order
4719    );
4720  }
4721      
4722// ----------------------------------------------------------------------------
4723// Filter/ImplReference
4724// ----------------------------------------------------------------------------
4725  public void forAllContext (
4726    short operator,
4727    org.openmdx.base.cci.Context[] filterValues
4728  ) {
4729    java.util.List   arrayAsList = new java.util.ArrayList  ();
4730    for(int i = 0; i < filterValues.length; i++) {
4731      arrayAsList.add(
4732        filterValues[i]
4733      );
4734    }
4735    forAllContext (
4736      operator,
4737      arrayAsList
4738    );
4739  }
4740
4741  public void thereExistsContext (
4742    short operator,
4743    org.openmdx.base.cci.Context[] filterValues
4744  ) {
4745    java.util.List   arrayAsList = new java.util.ArrayList  ();
4746    for(int i = 0; i < filterValues.length; i++) {
4747      arrayAsList.add(
4748        filterValues[i]
4749      );
4750    }
4751    thereExistsContext (
4752      operator,
4753      arrayAsList
4754    );
4755  }
4756
4757  public void forAllContext (
4758    short operator,
4759    java.util.Collection   values
4760  ) {
4761    refAddValue(
4762      "org:openmdx:base:ContextCapable:context",
4763      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4764      operator,
4765      values
4766    );
4767  }
4768
4769  public void thereExistsContext (
4770    short operator,
4771    java.util.Collection   values
4772  ) {
4773    refAddValue(
4774      "org:openmdx:base:ContextCapable:context",
4775      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4776      operator,
4777      values
4778    );
4779  }
4780      
4781// ----------------------------------------------------------------------------
4782// Filter/ImplAttributeIsNotStruct
4783// ----------------------------------------------------------------------------
4784  public void forAllIdentity (
4785    short operator,
4786    java.util.Collection   values
4787  ) {
4788    refAddValue(
4789      "org:openmdx:base:ExtentCapable:identity",
4790      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4791      operator,
4792      values
4793    );
4794  }
4795
4796  public void thereExistsIdentity (
4797    short operator,
4798    java.util.Collection   values
4799  ) {
4800    refAddValue(
4801      "org:openmdx:base:ExtentCapable:identity",
4802      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4803      operator,
4804      values
4805    );
4806  }
4807
4808  public void forAllIdentity (
4809    short operator,
4810    String  [] filterValues
4811  ) {
4812    java.util.List   arrayAsList = new java.util.ArrayList  ();
4813    for(int i = 0; i < filterValues.length; i++) {
4814      arrayAsList.add(
4815        filterValues[i]
4816      );
4817    }
4818    forAllIdentity (
4819      operator,
4820      arrayAsList
4821    );
4822  }
4823
4824  public void thereExistsIdentity (
4825    short operator,
4826    String  [] filterValues
4827  ) {
4828    java.util.List   arrayAsList = new java.util.ArrayList  ();
4829    for(int i = 0; i < filterValues.length; i++) {
4830      arrayAsList.add(
4831        filterValues[i]
4832      );
4833    }
4834    thereExistsIdentity (
4835      operator,
4836      arrayAsList
4837    );
4838  }
4839
4840  public void orderByIdentity (
4841    short order
4842  ) {
4843    refAddValue(
4844      "org:openmdx:base:ExtentCapable:identity",
4845      order
4846    );
4847  }
4848      
4849// ----------------------------------------------------------------------------
4850// Filter/ImplEnd
4851// ----------------------------------------------------------------------------
4852}        
4853
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags