SmsFilterImpl


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:02 CEST 2006
9   //
10  // GENERATED - DO NOT CHANGE MANUALLY
11  //
12  //////////////////////////////////////////////////////////////////////////////
13  package org.opencrx.kernel.activity1.cci;
14  
15  public class SmsFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements SmsFilter {
18  
19    public SmsFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:activity1:Sms",
25        null,
26        null
27      );
28    }
29  
30    public SmsFilterImpl(
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:Sms",
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 forAllMessageBody (
1752    short operator,
1753    java.util.Collection   values
1754  ) {
1755    refAddValue(
1756      "org:opencrx:kernel:activity1:Sms:messageBody",
1757      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1758      operator,
1759      values
1760    );
1761  }
1762
1763  public void thereExistsMessageBody (
1764    short operator,
1765    java.util.Collection   values
1766  ) {
1767    refAddValue(
1768      "org:opencrx:kernel:activity1:Sms:messageBody",
1769      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1770      operator,
1771      values
1772    );
1773  }
1774
1775  public void forAllMessageBody (
1776    short operator,
1777    String  [] filterValues
1778  ) {
1779    java.util.List   arrayAsList = new java.util.ArrayList  ();
1780    for(int i = 0; i < filterValues.length; i++) {
1781      arrayAsList.add(
1782        filterValues[i]
1783      );
1784    }
1785    forAllMessageBody (
1786      operator,
1787      arrayAsList
1788    );
1789  }
1790
1791  public void thereExistsMessageBody (
1792    short operator,
1793    String  [] filterValues
1794  ) {
1795    java.util.List   arrayAsList = new java.util.ArrayList  ();
1796    for(int i = 0; i < filterValues.length; i++) {
1797      arrayAsList.add(
1798        filterValues[i]
1799      );
1800    }
1801    thereExistsMessageBody (
1802      operator,
1803      arrayAsList
1804    );
1805  }
1806
1807  public void orderByMessageBody (
1808    short order
1809  ) {
1810    refAddValue(
1811      "org:opencrx:kernel:activity1:Sms:messageBody",
1812      order
1813    );
1814  }
1815      
1816// ----------------------------------------------------------------------------
1817// Filter/ImplAttributeIsNotStruct
1818// ----------------------------------------------------------------------------
1819  public void forAllSendDate (
1820    short operator,
1821    java.util.Collection   values
1822  ) {
1823    refAddValue(
1824      "org:opencrx:kernel:activity1:Sms:sendDate",
1825      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1826      operator,
1827      values
1828    );
1829  }
1830
1831  public void thereExistsSendDate (
1832    short operator,
1833    java.util.Collection   values
1834  ) {
1835    refAddValue(
1836      "org:opencrx:kernel:activity1:Sms:sendDate",
1837      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1838      operator,
1839      values
1840    );
1841  }
1842
1843  public void forAllSendDate (
1844    short operator,
1845    java.util.Date  [] filterValues
1846  ) {
1847    java.util.List   arrayAsList = new java.util.ArrayList  ();
1848    for(int i = 0; i < filterValues.length; i++) {
1849      arrayAsList.add(
1850        filterValues[i]
1851      );
1852    }
1853    forAllSendDate (
1854      operator,
1855      arrayAsList
1856    );
1857  }
1858
1859  public void thereExistsSendDate (
1860    short operator,
1861    java.util.Date  [] filterValues
1862  ) {
1863    java.util.List   arrayAsList = new java.util.ArrayList  ();
1864    for(int i = 0; i < filterValues.length; i++) {
1865      arrayAsList.add(
1866        filterValues[i]
1867      );
1868    }
1869    thereExistsSendDate (
1870      operator,
1871      arrayAsList
1872    );
1873  }
1874
1875  public void orderBySendDate (
1876    short order
1877  ) {
1878    refAddValue(
1879      "org:opencrx:kernel:activity1:Sms:sendDate",
1880      order
1881    );
1882  }
1883      
1884// ----------------------------------------------------------------------------
1885// Filter/ImplReference
1886// ----------------------------------------------------------------------------
1887  public void forAllSender (
1888    short operator,
1889    org.opencrx.kernel.account1.cci.PhoneNumber[] filterValues
1890  ) {
1891    java.util.List   arrayAsList = new java.util.ArrayList  ();
1892    for(int i = 0; i < filterValues.length; i++) {
1893      arrayAsList.add(
1894        filterValues[i]
1895      );
1896    }
1897    forAllSender (
1898      operator,
1899      arrayAsList
1900    );
1901  }
1902
1903  public void thereExistsSender (
1904    short operator,
1905    org.opencrx.kernel.account1.cci.PhoneNumber[] filterValues
1906  ) {
1907    java.util.List   arrayAsList = new java.util.ArrayList  ();
1908    for(int i = 0; i < filterValues.length; i++) {
1909      arrayAsList.add(
1910        filterValues[i]
1911      );
1912    }
1913    thereExistsSender (
1914      operator,
1915      arrayAsList
1916    );
1917  }
1918
1919  public void forAllSender (
1920    short operator,
1921    java.util.Collection   values
1922  ) {
1923    refAddValue(
1924      "org:opencrx:kernel:activity1:Sms:sender",
1925      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1926      operator,
1927      values
1928    );
1929  }
1930
1931  public void thereExistsSender (
1932    short operator,
1933    java.util.Collection   values
1934  ) {
1935    refAddValue(
1936      "org:opencrx:kernel:activity1:Sms:sender",
1937      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1938      operator,
1939      values
1940    );
1941  }
1942      
1943// ----------------------------------------------------------------------------
1944// Filter/ImplAttributeIsNotStruct
1945// ----------------------------------------------------------------------------
1946  public void forAllAccessLevelBrowse (
1947    short operator,
1948    java.util.Collection   values
1949  ) {
1950    refAddValue(
1951      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1952      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1953      operator,
1954      values
1955    );
1956  }
1957
1958  public void thereExistsAccessLevelBrowse (
1959    short operator,
1960    java.util.Collection   values
1961  ) {
1962    refAddValue(
1963      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1964      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1965      operator,
1966      values
1967    );
1968  }
1969
1970  public void forAllAccessLevelBrowse (
1971    short operator,
1972    short[] filterValues
1973  ) {
1974    java.util.List   arrayAsList = new java.util.ArrayList  ();
1975    for(int i = 0; i < filterValues.length; i++) {
1976      arrayAsList.add(
1977        new Short  (filterValues[i])
1978      );
1979    }
1980    forAllAccessLevelBrowse (
1981      operator,
1982      arrayAsList
1983    );
1984  }
1985
1986  public void thereExistsAccessLevelBrowse (
1987    short operator,
1988    short[] filterValues
1989  ) {
1990    java.util.List   arrayAsList = new java.util.ArrayList  ();
1991    for(int i = 0; i < filterValues.length; i++) {
1992      arrayAsList.add(
1993        new Short  (filterValues[i])
1994      );
1995    }
1996    thereExistsAccessLevelBrowse (
1997      operator,
1998      arrayAsList
1999    );
2000  }
2001
2002  public void orderByAccessLevelBrowse (
2003    short order
2004  ) {
2005    refAddValue(
2006      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
2007      order
2008    );
2009  }
2010      
2011// ----------------------------------------------------------------------------
2012// Filter/ImplAttributeIsNotStruct
2013// ----------------------------------------------------------------------------
2014  public void forAllAccessLevelDelete (
2015    short operator,
2016    java.util.Collection   values
2017  ) {
2018    refAddValue(
2019      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
2020      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2021      operator,
2022      values
2023    );
2024  }
2025
2026  public void thereExistsAccessLevelDelete (
2027    short operator,
2028    java.util.Collection   values
2029  ) {
2030    refAddValue(
2031      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
2032      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2033      operator,
2034      values
2035    );
2036  }
2037
2038  public void forAllAccessLevelDelete (
2039    short operator,
2040    short[] filterValues
2041  ) {
2042    java.util.List   arrayAsList = new java.util.ArrayList  ();
2043    for(int i = 0; i < filterValues.length; i++) {
2044      arrayAsList.add(
2045        new Short  (filterValues[i])
2046      );
2047    }
2048    forAllAccessLevelDelete (
2049      operator,
2050      arrayAsList
2051    );
2052  }
2053
2054  public void thereExistsAccessLevelDelete (
2055    short operator,
2056    short[] filterValues
2057  ) {
2058    java.util.List   arrayAsList = new java.util.ArrayList  ();
2059    for(int i = 0; i < filterValues.length; i++) {
2060      arrayAsList.add(
2061        new Short  (filterValues[i])
2062      );
2063    }
2064    thereExistsAccessLevelDelete (
2065      operator,
2066      arrayAsList
2067    );
2068  }
2069
2070  public void orderByAccessLevelDelete (
2071    short order
2072  ) {
2073    refAddValue(
2074      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
2075      order
2076    );
2077  }
2078      
2079// ----------------------------------------------------------------------------
2080// Filter/ImplAttributeIsNotStruct
2081// ----------------------------------------------------------------------------
2082  public void forAllAccessLevelUpdate (
2083    short operator,
2084    java.util.Collection   values
2085  ) {
2086    refAddValue(
2087      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
2088      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2089      operator,
2090      values
2091    );
2092  }
2093
2094  public void thereExistsAccessLevelUpdate (
2095    short operator,
2096    java.util.Collection   values
2097  ) {
2098    refAddValue(
2099      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
2100      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2101      operator,
2102      values
2103    );
2104  }
2105
2106  public void forAllAccessLevelUpdate (
2107    short operator,
2108    short[] filterValues
2109  ) {
2110    java.util.List   arrayAsList = new java.util.ArrayList  ();
2111    for(int i = 0; i < filterValues.length; i++) {
2112      arrayAsList.add(
2113        new Short  (filterValues[i])
2114      );
2115    }
2116    forAllAccessLevelUpdate (
2117      operator,
2118      arrayAsList
2119    );
2120  }
2121
2122  public void thereExistsAccessLevelUpdate (
2123    short operator,
2124    short[] filterValues
2125  ) {
2126    java.util.List   arrayAsList = new java.util.ArrayList  ();
2127    for(int i = 0; i < filterValues.length; i++) {
2128      arrayAsList.add(
2129        new Short  (filterValues[i])
2130      );
2131    }
2132    thereExistsAccessLevelUpdate (
2133      operator,
2134      arrayAsList
2135    );
2136  }
2137
2138  public void orderByAccessLevelUpdate (
2139    short order
2140  ) {
2141    refAddValue(
2142      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
2143      order
2144    );
2145  }
2146      
2147// ----------------------------------------------------------------------------
2148// Filter/ImplAttributeIsNotStruct
2149// ----------------------------------------------------------------------------
2150  public void forAllOwner (
2151    short operator,
2152    java.util.Collection   values
2153  ) {
2154    refAddValue(
2155      "org:opencrx:kernel:base:SecureObject:owner",
2156      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2157      operator,
2158      values
2159    );
2160  }
2161
2162  public void thereExistsOwner (
2163    short operator,
2164    java.util.Collection   values
2165  ) {
2166    refAddValue(
2167      "org:opencrx:kernel:base:SecureObject:owner",
2168      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2169      operator,
2170      values
2171    );
2172  }
2173
2174  public void forAllOwner (
2175    short operator,
2176    String  [] filterValues
2177  ) {
2178    java.util.List   arrayAsList = new java.util.ArrayList  ();
2179    for(int i = 0; i < filterValues.length; i++) {
2180      arrayAsList.add(
2181        filterValues[i]
2182      );
2183    }
2184    forAllOwner (
2185      operator,
2186      arrayAsList
2187    );
2188  }
2189
2190  public void thereExistsOwner (
2191    short operator,
2192    String  [] filterValues
2193  ) {
2194    java.util.List   arrayAsList = new java.util.ArrayList  ();
2195    for(int i = 0; i < filterValues.length; i++) {
2196      arrayAsList.add(
2197        filterValues[i]
2198      );
2199    }
2200    thereExistsOwner (
2201      operator,
2202      arrayAsList
2203    );
2204  }
2205
2206  public void orderByOwner (
2207    short order
2208  ) {
2209    refAddValue(
2210      "org:opencrx:kernel:base:SecureObject:owner",
2211      order
2212    );
2213  }
2214      
2215// ----------------------------------------------------------------------------
2216// Filter/ImplReference
2217// ----------------------------------------------------------------------------
2218  public void forAllOwningGroup (
2219    short operator,
2220    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2221  ) {
2222    java.util.List   arrayAsList = new java.util.ArrayList  ();
2223    for(int i = 0; i < filterValues.length; i++) {
2224      arrayAsList.add(
2225        filterValues[i]
2226      );
2227    }
2228    forAllOwningGroup (
2229      operator,
2230      arrayAsList
2231    );
2232  }
2233
2234  public void thereExistsOwningGroup (
2235    short operator,
2236    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2237  ) {
2238    java.util.List   arrayAsList = new java.util.ArrayList  ();
2239    for(int i = 0; i < filterValues.length; i++) {
2240      arrayAsList.add(
2241        filterValues[i]
2242      );
2243    }
2244    thereExistsOwningGroup (
2245      operator,
2246      arrayAsList
2247    );
2248  }
2249
2250  public void forAllOwningGroup (
2251    short operator,
2252    java.util.Collection   values
2253  ) {
2254    refAddValue(
2255      "org:opencrx:kernel:base:SecureObject:owningGroup",
2256      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2257      operator,
2258      values
2259    );
2260  }
2261
2262  public void thereExistsOwningGroup (
2263    short operator,
2264    java.util.Collection   values
2265  ) {
2266    refAddValue(
2267      "org:opencrx:kernel:base:SecureObject:owningGroup",
2268      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2269      operator,
2270      values
2271    );
2272  }
2273      
2274// ----------------------------------------------------------------------------
2275// Filter/ImplReference
2276// ----------------------------------------------------------------------------
2277  public void forAllOwningUser (
2278    short operator,
2279    org.opencrx.security.realm1.cci.User[] filterValues
2280  ) {
2281    java.util.List   arrayAsList = new java.util.ArrayList  ();
2282    for(int i = 0; i < filterValues.length; i++) {
2283      arrayAsList.add(
2284        filterValues[i]
2285      );
2286    }
2287    forAllOwningUser (
2288      operator,
2289      arrayAsList
2290    );
2291  }
2292
2293  public void thereExistsOwningUser (
2294    short operator,
2295    org.opencrx.security.realm1.cci.User[] filterValues
2296  ) {
2297    java.util.List   arrayAsList = new java.util.ArrayList  ();
2298    for(int i = 0; i < filterValues.length; i++) {
2299      arrayAsList.add(
2300        filterValues[i]
2301      );
2302    }
2303    thereExistsOwningUser (
2304      operator,
2305      arrayAsList
2306    );
2307  }
2308
2309  public void forAllOwningUser (
2310    short operator,
2311    java.util.Collection   values
2312  ) {
2313    refAddValue(
2314      "org:opencrx:kernel:base:SecureObject:owningUser",
2315      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2316      operator,
2317      values
2318    );
2319  }
2320
2321  public void thereExistsOwningUser (
2322    short operator,
2323    java.util.Collection   values
2324  ) {
2325    refAddValue(
2326      "org:opencrx:kernel:base:SecureObject:owningUser",
2327      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2328      operator,
2329      values
2330    );
2331  }
2332      
2333// ----------------------------------------------------------------------------
2334// Filter/ImplAttributeIsNotStruct
2335// ----------------------------------------------------------------------------
2336  public void forAllCategory (
2337    short operator,
2338    java.util.Collection   values
2339  ) {
2340    refAddValue(
2341      "org:opencrx:kernel:generic:CrxObject:category",
2342      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2343      operator,
2344      values
2345    );
2346  }
2347
2348  public void thereExistsCategory (
2349    short operator,
2350    java.util.Collection   values
2351  ) {
2352    refAddValue(
2353      "org:opencrx:kernel:generic:CrxObject:category",
2354      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2355      operator,
2356      values
2357    );
2358  }
2359
2360  public void forAllCategory (
2361    short operator,
2362    String  [] filterValues
2363  ) {
2364    java.util.List   arrayAsList = new java.util.ArrayList  ();
2365    for(int i = 0; i < filterValues.length; i++) {
2366      arrayAsList.add(
2367        filterValues[i]
2368      );
2369    }
2370    forAllCategory (
2371      operator,
2372      arrayAsList
2373    );
2374  }
2375
2376  public void thereExistsCategory (
2377    short operator,
2378    String  [] filterValues
2379  ) {
2380    java.util.List   arrayAsList = new java.util.ArrayList  ();
2381    for(int i = 0; i < filterValues.length; i++) {
2382      arrayAsList.add(
2383        filterValues[i]
2384      );
2385    }
2386    thereExistsCategory (
2387      operator,
2388      arrayAsList
2389    );
2390  }
2391
2392  public void orderByCategory (
2393    short order
2394  ) {
2395    refAddValue(
2396      "org:opencrx:kernel:generic:CrxObject:category",
2397      order
2398    );
2399  }
2400      
2401// ----------------------------------------------------------------------------
2402// Filter/ImplAttributeIsNotStruct
2403// ----------------------------------------------------------------------------
2404  public void forAllDisabled (
2405    short operator,
2406    java.util.Collection   values
2407  ) {
2408    refAddValue(
2409      "org:opencrx:kernel:generic:CrxObject:disabled",
2410      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2411      operator,
2412      values
2413    );
2414  }
2415
2416  public void thereExistsDisabled (
2417    short operator,
2418    java.util.Collection   values
2419  ) {
2420    refAddValue(
2421      "org:opencrx:kernel:generic:CrxObject:disabled",
2422      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2423      operator,
2424      values
2425    );
2426  }
2427
2428  public void forAllDisabled (
2429    short operator,
2430    boolean[] filterValues
2431  ) {
2432    java.util.List   arrayAsList = new java.util.ArrayList  ();
2433    for(int i = 0; i < filterValues.length; i++) {
2434      arrayAsList.add(
2435        new Boolean  (filterValues[i])
2436      );
2437    }
2438    forAllDisabled (
2439      operator,
2440      arrayAsList
2441    );
2442  }
2443
2444  public void thereExistsDisabled (
2445    short operator,
2446    boolean[] filterValues
2447  ) {
2448    java.util.List   arrayAsList = new java.util.ArrayList  ();
2449    for(int i = 0; i < filterValues.length; i++) {
2450      arrayAsList.add(
2451        new Boolean  (filterValues[i])
2452      );
2453    }
2454    thereExistsDisabled (
2455      operator,
2456      arrayAsList
2457    );
2458  }
2459
2460  public void orderByDisabled (
2461    short order
2462  ) {
2463    refAddValue(
2464      "org:opencrx:kernel:generic:CrxObject:disabled",
2465      order
2466    );
2467  }
2468      
2469// ----------------------------------------------------------------------------
2470// Filter/ImplAttributeIsNotStruct
2471// ----------------------------------------------------------------------------
2472  public void forAllDisabledReason (
2473    short operator,
2474    java.util.Collection   values
2475  ) {
2476    refAddValue(
2477      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2478      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2479      operator,
2480      values
2481    );
2482  }
2483
2484  public void thereExistsDisabledReason (
2485    short operator,
2486    java.util.Collection   values
2487  ) {
2488    refAddValue(
2489      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2490      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2491      operator,
2492      values
2493    );
2494  }
2495
2496  public void forAllDisabledReason (
2497    short operator,
2498    String  [] filterValues
2499  ) {
2500    java.util.List   arrayAsList = new java.util.ArrayList  ();
2501    for(int i = 0; i < filterValues.length; i++) {
2502      arrayAsList.add(
2503        filterValues[i]
2504      );
2505    }
2506    forAllDisabledReason (
2507      operator,
2508      arrayAsList
2509    );
2510  }
2511
2512  public void thereExistsDisabledReason (
2513    short operator,
2514    String  [] filterValues
2515  ) {
2516    java.util.List   arrayAsList = new java.util.ArrayList  ();
2517    for(int i = 0; i < filterValues.length; i++) {
2518      arrayAsList.add(
2519        filterValues[i]
2520      );
2521    }
2522    thereExistsDisabledReason (
2523      operator,
2524      arrayAsList
2525    );
2526  }
2527
2528  public void orderByDisabledReason (
2529    short order
2530  ) {
2531    refAddValue(
2532      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2533      order
2534    );
2535  }
2536      
2537// ----------------------------------------------------------------------------
2538// Filter/ImplAttributeIsNotStruct
2539// ----------------------------------------------------------------------------
2540  public void forAllExternalLink (
2541    short operator,
2542    java.util.Collection   values
2543  ) {
2544    refAddValue(
2545      "org:opencrx:kernel:generic:CrxObject:externalLink",
2546      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2547      operator,
2548      values
2549    );
2550  }
2551
2552  public void thereExistsExternalLink (
2553    short operator,
2554    java.util.Collection   values
2555  ) {
2556    refAddValue(
2557      "org:opencrx:kernel:generic:CrxObject:externalLink",
2558      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2559      operator,
2560      values
2561    );
2562  }
2563
2564  public void forAllExternalLink (
2565    short operator,
2566    String  [] filterValues
2567  ) {
2568    java.util.List   arrayAsList = new java.util.ArrayList  ();
2569    for(int i = 0; i < filterValues.length; i++) {
2570      arrayAsList.add(
2571        filterValues[i]
2572      );
2573    }
2574    forAllExternalLink (
2575      operator,
2576      arrayAsList
2577    );
2578  }
2579
2580  public void thereExistsExternalLink (
2581    short operator,
2582    String  [] filterValues
2583  ) {
2584    java.util.List   arrayAsList = new java.util.ArrayList  ();
2585    for(int i = 0; i < filterValues.length; i++) {
2586      arrayAsList.add(
2587        filterValues[i]
2588      );
2589    }
2590    thereExistsExternalLink (
2591      operator,
2592      arrayAsList
2593    );
2594  }
2595
2596  public void orderByExternalLink (
2597    short order
2598  ) {
2599    refAddValue(
2600      "org:opencrx:kernel:generic:CrxObject:externalLink",
2601      order
2602    );
2603  }
2604      
2605// ----------------------------------------------------------------------------
2606// Filter/ImplAttributeIsNotStruct
2607// ----------------------------------------------------------------------------
2608  public void forAllUserBoolean0 (
2609    short operator,
2610    java.util.Collection   values
2611  ) {
2612    refAddValue(
2613      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2614      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2615      operator,
2616      values
2617    );
2618  }
2619
2620  public void thereExistsUserBoolean0 (
2621    short operator,
2622    java.util.Collection   values
2623  ) {
2624    refAddValue(
2625      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2626      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2627      operator,
2628      values
2629    );
2630  }
2631
2632  public void forAllUserBoolean0 (
2633    short operator,
2634    boolean[] filterValues
2635  ) {
2636    java.util.List   arrayAsList = new java.util.ArrayList  ();
2637    for(int i = 0; i < filterValues.length; i++) {
2638      arrayAsList.add(
2639        new Boolean  (filterValues[i])
2640      );
2641    }
2642    forAllUserBoolean0 (
2643      operator,
2644      arrayAsList
2645    );
2646  }
2647
2648  public void thereExistsUserBoolean0 (
2649    short operator,
2650    boolean[] filterValues
2651  ) {
2652    java.util.List   arrayAsList = new java.util.ArrayList  ();
2653    for(int i = 0; i < filterValues.length; i++) {
2654      arrayAsList.add(
2655        new Boolean  (filterValues[i])
2656      );
2657    }
2658    thereExistsUserBoolean0 (
2659      operator,
2660      arrayAsList
2661    );
2662  }
2663
2664  public void orderByUserBoolean0 (
2665    short order
2666  ) {
2667    refAddValue(
2668      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2669      order
2670    );
2671  }
2672      
2673// ----------------------------------------------------------------------------
2674// Filter/ImplAttributeIsNotStruct
2675// ----------------------------------------------------------------------------
2676  public void forAllUserBoolean1 (
2677    short operator,
2678    java.util.Collection   values
2679  ) {
2680    refAddValue(
2681      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2682      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2683      operator,
2684      values
2685    );
2686  }
2687
2688  public void thereExistsUserBoolean1 (
2689    short operator,
2690    java.util.Collection   values
2691  ) {
2692    refAddValue(
2693      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2694      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2695      operator,
2696      values
2697    );
2698  }
2699
2700  public void forAllUserBoolean1 (
2701    short operator,
2702    boolean[] filterValues
2703  ) {
2704    java.util.List   arrayAsList = new java.util.ArrayList  ();
2705    for(int i = 0; i < filterValues.length; i++) {
2706      arrayAsList.add(
2707        new Boolean  (filterValues[i])
2708      );
2709    }
2710    forAllUserBoolean1 (
2711      operator,
2712      arrayAsList
2713    );
2714  }
2715
2716  public void thereExistsUserBoolean1 (
2717    short operator,
2718    boolean[] filterValues
2719  ) {
2720    java.util.List   arrayAsList = new java.util.ArrayList  ();
2721    for(int i = 0; i < filterValues.length; i++) {
2722      arrayAsList.add(
2723        new Boolean  (filterValues[i])
2724      );
2725    }
2726    thereExistsUserBoolean1 (
2727      operator,
2728      arrayAsList
2729    );
2730  }
2731
2732  public void orderByUserBoolean1 (
2733    short order
2734  ) {
2735    refAddValue(
2736      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2737      order
2738    );
2739  }
2740      
2741// ----------------------------------------------------------------------------
2742// Filter/ImplAttributeIsNotStruct
2743// ----------------------------------------------------------------------------
2744  public void forAllUserBoolean2 (
2745    short operator,
2746    java.util.Collection   values
2747  ) {
2748    refAddValue(
2749      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2750      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2751      operator,
2752      values
2753    );
2754  }
2755
2756  public void thereExistsUserBoolean2 (
2757    short operator,
2758    java.util.Collection   values
2759  ) {
2760    refAddValue(
2761      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2762      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2763      operator,
2764      values
2765    );
2766  }
2767
2768  public void forAllUserBoolean2 (
2769    short operator,
2770    boolean[] filterValues
2771  ) {
2772    java.util.List   arrayAsList = new java.util.ArrayList  ();
2773    for(int i = 0; i < filterValues.length; i++) {
2774      arrayAsList.add(
2775        new Boolean  (filterValues[i])
2776      );
2777    }
2778    forAllUserBoolean2 (
2779      operator,
2780      arrayAsList
2781    );
2782  }
2783
2784  public void thereExistsUserBoolean2 (
2785    short operator,
2786    boolean[] filterValues
2787  ) {
2788    java.util.List   arrayAsList = new java.util.ArrayList  ();
2789    for(int i = 0; i < filterValues.length; i++) {
2790      arrayAsList.add(
2791        new Boolean  (filterValues[i])
2792      );
2793    }
2794    thereExistsUserBoolean2 (
2795      operator,
2796      arrayAsList
2797    );
2798  }
2799
2800  public void orderByUserBoolean2 (
2801    short order
2802  ) {
2803    refAddValue(
2804      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2805      order
2806    );
2807  }
2808      
2809// ----------------------------------------------------------------------------
2810// Filter/ImplAttributeIsNotStruct
2811// ----------------------------------------------------------------------------
2812  public void forAllUserBoolean3 (
2813    short operator,
2814    java.util.Collection   values
2815  ) {
2816    refAddValue(
2817      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2818      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2819      operator,
2820      values
2821    );
2822  }
2823
2824  public void thereExistsUserBoolean3 (
2825    short operator,
2826    java.util.Collection   values
2827  ) {
2828    refAddValue(
2829      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2830      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2831      operator,
2832      values
2833    );
2834  }
2835
2836  public void forAllUserBoolean3 (
2837    short operator,
2838    boolean[] filterValues
2839  ) {
2840    java.util.List   arrayAsList = new java.util.ArrayList  ();
2841    for(int i = 0; i < filterValues.length; i++) {
2842      arrayAsList.add(
2843        new Boolean  (filterValues[i])
2844      );
2845    }
2846    forAllUserBoolean3 (
2847      operator,
2848      arrayAsList
2849    );
2850  }
2851
2852  public void thereExistsUserBoolean3 (
2853    short operator,
2854    boolean[] filterValues
2855  ) {
2856    java.util.List   arrayAsList = new java.util.ArrayList  ();
2857    for(int i = 0; i < filterValues.length; i++) {
2858      arrayAsList.add(
2859        new Boolean  (filterValues[i])
2860      );
2861    }
2862    thereExistsUserBoolean3 (
2863      operator,
2864      arrayAsList
2865    );
2866  }
2867
2868  public void orderByUserBoolean3 (
2869    short order
2870  ) {
2871    refAddValue(
2872      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2873      order
2874    );
2875  }
2876      
2877// ----------------------------------------------------------------------------
2878// Filter/ImplAttributeIsNotStruct
2879// ----------------------------------------------------------------------------
2880  public void forAllUserBoolean4 (
2881    short operator,
2882    java.util.Collection   values
2883  ) {
2884    refAddValue(
2885      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2886      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2887      operator,
2888      values
2889    );
2890  }
2891
2892  public void thereExistsUserBoolean4 (
2893    short operator,
2894    java.util.Collection   values
2895  ) {
2896    refAddValue(
2897      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2898      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2899      operator,
2900      values
2901    );
2902  }
2903
2904  public void forAllUserBoolean4 (
2905    short operator,
2906    boolean[] filterValues
2907  ) {
2908    java.util.List   arrayAsList = new java.util.ArrayList  ();
2909    for(int i = 0; i < filterValues.length; i++) {
2910      arrayAsList.add(
2911        new Boolean  (filterValues[i])
2912      );
2913    }
2914    forAllUserBoolean4 (
2915      operator,
2916      arrayAsList
2917    );
2918  }
2919
2920  public void thereExistsUserBoolean4 (
2921    short operator,
2922    boolean[] filterValues
2923  ) {
2924    java.util.List   arrayAsList = new java.util.ArrayList  ();
2925    for(int i = 0; i < filterValues.length; i++) {
2926      arrayAsList.add(
2927        new Boolean  (filterValues[i])
2928      );
2929    }
2930    thereExistsUserBoolean4 (
2931      operator,
2932      arrayAsList
2933    );
2934  }
2935
2936  public void orderByUserBoolean4 (
2937    short order
2938  ) {
2939    refAddValue(
2940      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2941      order
2942    );
2943  }
2944      
2945// ----------------------------------------------------------------------------
2946// Filter/ImplAttributeIsNotStruct
2947// ----------------------------------------------------------------------------
2948  public void forAllUserCode0 (
2949    short operator,
2950    java.util.Collection   values
2951  ) {
2952    refAddValue(
2953      "org:opencrx:kernel:generic:CrxObject:userCode0",
2954      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2955      operator,
2956      values
2957    );
2958  }
2959
2960  public void thereExistsUserCode0 (
2961    short operator,
2962    java.util.Collection   values
2963  ) {
2964    refAddValue(
2965      "org:opencrx:kernel:generic:CrxObject:userCode0",
2966      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2967      operator,
2968      values
2969    );
2970  }
2971
2972  public void forAllUserCode0 (
2973    short operator,
2974    short[] filterValues
2975  ) {
2976    java.util.List   arrayAsList = new java.util.ArrayList  ();
2977    for(int i = 0; i < filterValues.length; i++) {
2978      arrayAsList.add(
2979        new Short  (filterValues[i])
2980      );
2981    }
2982    forAllUserCode0 (
2983      operator,
2984      arrayAsList
2985    );
2986  }
2987
2988  public void thereExistsUserCode0 (
2989    short operator,
2990    short[] filterValues
2991  ) {
2992    java.util.List   arrayAsList = new java.util.ArrayList  ();
2993    for(int i = 0; i < filterValues.length; i++) {
2994      arrayAsList.add(
2995        new Short  (filterValues[i])
2996      );
2997    }
2998    thereExistsUserCode0 (
2999      operator,
3000      arrayAsList
3001    );
3002  }
3003
3004  public void orderByUserCode0 (
3005    short order
3006  ) {
3007    refAddValue(
3008      "org:opencrx:kernel:generic:CrxObject:userCode0",
3009      order
3010    );
3011  }
3012      
3013// ----------------------------------------------------------------------------
3014// Filter/ImplAttributeIsNotStruct
3015// ----------------------------------------------------------------------------
3016  public void forAllUserCode1 (
3017    short operator,
3018    java.util.Collection   values
3019  ) {
3020    refAddValue(
3021      "org:opencrx:kernel:generic:CrxObject:userCode1",
3022      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3023      operator,
3024      values
3025    );
3026  }
3027
3028  public void thereExistsUserCode1 (
3029    short operator,
3030    java.util.Collection   values
3031  ) {
3032    refAddValue(
3033      "org:opencrx:kernel:generic:CrxObject:userCode1",
3034      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3035      operator,
3036      values
3037    );
3038  }
3039
3040  public void forAllUserCode1 (
3041    short operator,
3042    short[] filterValues
3043  ) {
3044    java.util.List   arrayAsList = new java.util.ArrayList  ();
3045    for(int i = 0; i < filterValues.length; i++) {
3046      arrayAsList.add(
3047        new Short  (filterValues[i])
3048      );
3049    }
3050    forAllUserCode1 (
3051      operator,
3052      arrayAsList
3053    );
3054  }
3055
3056  public void thereExistsUserCode1 (
3057    short operator,
3058    short[] filterValues
3059  ) {
3060    java.util.List   arrayAsList = new java.util.ArrayList  ();
3061    for(int i = 0; i < filterValues.length; i++) {
3062      arrayAsList.add(
3063        new Short  (filterValues[i])
3064      );
3065    }
3066    thereExistsUserCode1 (
3067      operator,
3068      arrayAsList
3069    );
3070  }
3071
3072  public void orderByUserCode1 (
3073    short order
3074  ) {
3075    refAddValue(
3076      "org:opencrx:kernel:generic:CrxObject:userCode1",
3077      order
3078    );
3079  }
3080      
3081// ----------------------------------------------------------------------------
3082// Filter/ImplAttributeIsNotStruct
3083// ----------------------------------------------------------------------------
3084  public void forAllUserCode2 (
3085    short operator,
3086    java.util.Collection   values
3087  ) {
3088    refAddValue(
3089      "org:opencrx:kernel:generic:CrxObject:userCode2",
3090      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3091      operator,
3092      values
3093    );
3094  }
3095
3096  public void thereExistsUserCode2 (
3097    short operator,
3098    java.util.Collection   values
3099  ) {
3100    refAddValue(
3101      "org:opencrx:kernel:generic:CrxObject:userCode2",
3102      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3103      operator,
3104      values
3105    );
3106  }
3107
3108  public void forAllUserCode2 (
3109    short operator,
3110    short[] filterValues
3111  ) {
3112    java.util.List   arrayAsList = new java.util.ArrayList  ();
3113    for(int i = 0; i < filterValues.length; i++) {
3114      arrayAsList.add(
3115        new Short  (filterValues[i])
3116      );
3117    }
3118    forAllUserCode2 (
3119      operator,
3120      arrayAsList
3121    );
3122  }
3123
3124  public void thereExistsUserCode2 (
3125    short operator,
3126    short[] filterValues
3127  ) {
3128    java.util.List   arrayAsList = new java.util.ArrayList  ();
3129    for(int i = 0; i < filterValues.length; i++) {
3130      arrayAsList.add(
3131        new Short  (filterValues[i])
3132      );
3133    }
3134    thereExistsUserCode2 (
3135      operator,
3136      arrayAsList
3137    );
3138  }
3139
3140  public void orderByUserCode2 (
3141    short order
3142  ) {
3143    refAddValue(
3144      "org:opencrx:kernel:generic:CrxObject:userCode2",
3145      order
3146    );
3147  }
3148      
3149// ----------------------------------------------------------------------------
3150// Filter/ImplAttributeIsNotStruct
3151// ----------------------------------------------------------------------------
3152  public void forAllUserCode3 (
3153    short operator,
3154    java.util.Collection   values
3155  ) {
3156    refAddValue(
3157      "org:opencrx:kernel:generic:CrxObject:userCode3",
3158      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3159      operator,
3160      values
3161    );
3162  }
3163
3164  public void thereExistsUserCode3 (
3165    short operator,
3166    java.util.Collection   values
3167  ) {
3168    refAddValue(
3169      "org:opencrx:kernel:generic:CrxObject:userCode3",
3170      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3171      operator,
3172      values
3173    );
3174  }
3175
3176  public void forAllUserCode3 (
3177    short operator,
3178    short[] filterValues
3179  ) {
3180    java.util.List   arrayAsList = new java.util.ArrayList  ();
3181    for(int i = 0; i < filterValues.length; i++) {
3182      arrayAsList.add(
3183        new Short  (filterValues[i])
3184      );
3185    }
3186    forAllUserCode3 (
3187      operator,
3188      arrayAsList
3189    );
3190  }
3191
3192  public void thereExistsUserCode3 (
3193    short operator,
3194    short[] filterValues
3195  ) {
3196    java.util.List   arrayAsList = new java.util.ArrayList  ();
3197    for(int i = 0; i < filterValues.length; i++) {
3198      arrayAsList.add(
3199        new Short  (filterValues[i])
3200      );
3201    }
3202    thereExistsUserCode3 (
3203      operator,
3204      arrayAsList
3205    );
3206  }
3207
3208  public void orderByUserCode3 (
3209    short order
3210  ) {
3211    refAddValue(
3212      "org:opencrx:kernel:generic:CrxObject:userCode3",
3213      order
3214    );
3215  }
3216      
3217// ----------------------------------------------------------------------------
3218// Filter/ImplAttributeIsNotStruct
3219// ----------------------------------------------------------------------------
3220  public void forAllUserCode4 (
3221    short operator,
3222    java.util.Collection   values
3223  ) {
3224    refAddValue(
3225      "org:opencrx:kernel:generic:CrxObject:userCode4",
3226      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3227      operator,
3228      values
3229    );
3230  }
3231
3232  public void thereExistsUserCode4 (
3233    short operator,
3234    java.util.Collection   values
3235  ) {
3236    refAddValue(
3237      "org:opencrx:kernel:generic:CrxObject:userCode4",
3238      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3239      operator,
3240      values
3241    );
3242  }
3243
3244  public void forAllUserCode4 (
3245    short operator,
3246    short[] filterValues
3247  ) {
3248    java.util.List   arrayAsList = new java.util.ArrayList  ();
3249    for(int i = 0; i < filterValues.length; i++) {
3250      arrayAsList.add(
3251        new Short  (filterValues[i])
3252      );
3253    }
3254    forAllUserCode4 (
3255      operator,
3256      arrayAsList
3257    );
3258  }
3259
3260  public void thereExistsUserCode4 (
3261    short operator,
3262    short[] filterValues
3263  ) {
3264    java.util.List   arrayAsList = new java.util.ArrayList  ();
3265    for(int i = 0; i < filterValues.length; i++) {
3266      arrayAsList.add(
3267        new Short  (filterValues[i])
3268      );
3269    }
3270    thereExistsUserCode4 (
3271      operator,
3272      arrayAsList
3273    );
3274  }
3275
3276  public void orderByUserCode4 (
3277    short order
3278  ) {
3279    refAddValue(
3280      "org:opencrx:kernel:generic:CrxObject:userCode4",
3281      order
3282    );
3283  }
3284      
3285// ----------------------------------------------------------------------------
3286// Filter/ImplAttributeIsNotStruct
3287// ----------------------------------------------------------------------------
3288  public void forAllUserDate0 (
3289    short operator,
3290    java.util.Collection   values
3291  ) {
3292    refAddValue(
3293      "org:opencrx:kernel:generic:CrxObject:userDate0",
3294      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3295      operator,
3296      values
3297    );
3298  }
3299
3300  public void thereExistsUserDate0 (
3301    short operator,
3302    java.util.Collection   values
3303  ) {
3304    refAddValue(
3305      "org:opencrx:kernel:generic:CrxObject:userDate0",
3306      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3307      operator,
3308      values
3309    );
3310  }
3311
3312  public void forAllUserDate0 (
3313    short operator,
3314    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3315  ) {
3316    java.util.List   arrayAsList = new java.util.ArrayList  ();
3317    for(int i = 0; i < filterValues.length; i++) {
3318      arrayAsList.add(
3319        filterValues[i]
3320      );
3321    }
3322    forAllUserDate0 (
3323      operator,
3324      arrayAsList
3325    );
3326  }
3327
3328  public void thereExistsUserDate0 (
3329    short operator,
3330    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3331  ) {
3332    java.util.List   arrayAsList = new java.util.ArrayList  ();
3333    for(int i = 0; i < filterValues.length; i++) {
3334      arrayAsList.add(
3335        filterValues[i]
3336      );
3337    }
3338    thereExistsUserDate0 (
3339      operator,
3340      arrayAsList
3341    );
3342  }
3343
3344  public void orderByUserDate0 (
3345    short order
3346  ) {
3347    refAddValue(
3348      "org:opencrx:kernel:generic:CrxObject:userDate0",
3349      order
3350    );
3351  }
3352      
3353// ----------------------------------------------------------------------------
3354// Filter/ImplAttributeIsNotStruct
3355// ----------------------------------------------------------------------------
3356  public void forAllUserDate1 (
3357    short operator,
3358    java.util.Collection   values
3359  ) {
3360    refAddValue(
3361      "org:opencrx:kernel:generic:CrxObject:userDate1",
3362      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3363      operator,
3364      values
3365    );
3366  }
3367
3368  public void thereExistsUserDate1 (
3369    short operator,
3370    java.util.Collection   values
3371  ) {
3372    refAddValue(
3373      "org:opencrx:kernel:generic:CrxObject:userDate1",
3374      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3375      operator,
3376      values
3377    );
3378  }
3379
3380  public void forAllUserDate1 (
3381    short operator,
3382    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3383  ) {
3384    java.util.List   arrayAsList = new java.util.ArrayList  ();
3385    for(int i = 0; i < filterValues.length; i++) {
3386      arrayAsList.add(
3387        filterValues[i]
3388      );
3389    }
3390    forAllUserDate1 (
3391      operator,
3392      arrayAsList
3393    );
3394  }
3395
3396  public void thereExistsUserDate1 (
3397    short operator,
3398    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3399  ) {
3400    java.util.List   arrayAsList = new java.util.ArrayList  ();
3401    for(int i = 0; i < filterValues.length; i++) {
3402      arrayAsList.add(
3403        filterValues[i]
3404      );
3405    }
3406    thereExistsUserDate1 (
3407      operator,
3408      arrayAsList
3409    );
3410  }
3411
3412  public void orderByUserDate1 (
3413    short order
3414  ) {
3415    refAddValue(
3416      "org:opencrx:kernel:generic:CrxObject:userDate1",
3417      order
3418    );
3419  }
3420      
3421// ----------------------------------------------------------------------------
3422// Filter/ImplAttributeIsNotStruct
3423// ----------------------------------------------------------------------------
3424  public void forAllUserDate2 (
3425    short operator,
3426    java.util.Collection   values
3427  ) {
3428    refAddValue(
3429      "org:opencrx:kernel:generic:CrxObject:userDate2",
3430      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3431      operator,
3432      values
3433    );
3434  }
3435
3436  public void thereExistsUserDate2 (
3437    short operator,
3438    java.util.Collection   values
3439  ) {
3440    refAddValue(
3441      "org:opencrx:kernel:generic:CrxObject:userDate2",
3442      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3443      operator,
3444      values
3445    );
3446  }
3447
3448  public void forAllUserDate2 (
3449    short operator,
3450    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3451  ) {
3452    java.util.List   arrayAsList = new java.util.ArrayList  ();
3453    for(int i = 0; i < filterValues.length; i++) {
3454      arrayAsList.add(
3455        filterValues[i]
3456      );
3457    }
3458    forAllUserDate2 (
3459      operator,
3460      arrayAsList
3461    );
3462  }
3463
3464  public void thereExistsUserDate2 (
3465    short operator,
3466    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3467  ) {
3468    java.util.List   arrayAsList = new java.util.ArrayList  ();
3469    for(int i = 0; i < filterValues.length; i++) {
3470      arrayAsList.add(
3471        filterValues[i]
3472      );
3473    }
3474    thereExistsUserDate2 (
3475      operator,
3476      arrayAsList
3477    );
3478  }
3479
3480  public void orderByUserDate2 (
3481    short order
3482  ) {
3483    refAddValue(
3484      "org:opencrx:kernel:generic:CrxObject:userDate2",
3485      order
3486    );
3487  }
3488      
3489// ----------------------------------------------------------------------------
3490// Filter/ImplAttributeIsNotStruct
3491// ----------------------------------------------------------------------------
3492  public void forAllUserDate3 (
3493    short operator,
3494    java.util.Collection   values
3495  ) {
3496    refAddValue(
3497      "org:opencrx:kernel:generic:CrxObject:userDate3",
3498      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3499      operator,
3500      values
3501    );
3502  }
3503
3504  public void thereExistsUserDate3 (
3505    short operator,
3506    java.util.Collection   values
3507  ) {
3508    refAddValue(
3509      "org:opencrx:kernel:generic:CrxObject:userDate3",
3510      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3511      operator,
3512      values
3513    );
3514  }
3515
3516  public void forAllUserDate3 (
3517    short operator,
3518    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3519  ) {
3520    java.util.List   arrayAsList = new java.util.ArrayList  ();
3521    for(int i = 0; i < filterValues.length; i++) {
3522      arrayAsList.add(
3523        filterValues[i]
3524      );
3525    }
3526    forAllUserDate3 (
3527      operator,
3528      arrayAsList
3529    );
3530  }
3531
3532  public void thereExistsUserDate3 (
3533    short operator,
3534    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3535  ) {
3536    java.util.List   arrayAsList = new java.util.ArrayList  ();
3537    for(int i = 0; i < filterValues.length; i++) {
3538      arrayAsList.add(
3539        filterValues[i]
3540      );
3541    }
3542    thereExistsUserDate3 (
3543      operator,
3544      arrayAsList
3545    );
3546  }
3547
3548  public void orderByUserDate3 (
3549    short order
3550  ) {
3551    refAddValue(
3552      "org:opencrx:kernel:generic:CrxObject:userDate3",
3553      order
3554    );
3555  }
3556      
3557// ----------------------------------------------------------------------------
3558// Filter/ImplAttributeIsNotStruct
3559// ----------------------------------------------------------------------------
3560  public void forAllUserDate4 (
3561    short operator,
3562    java.util.Collection   values
3563  ) {
3564    refAddValue(
3565      "org:opencrx:kernel:generic:CrxObject:userDate4",
3566      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3567      operator,
3568      values
3569    );
3570  }
3571
3572  public void thereExistsUserDate4 (
3573    short operator,
3574    java.util.Collection   values
3575  ) {
3576    refAddValue(
3577      "org:opencrx:kernel:generic:CrxObject:userDate4",
3578      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3579      operator,
3580      values
3581    );
3582  }
3583
3584  public void forAllUserDate4 (
3585    short operator,
3586    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3587  ) {
3588    java.util.List   arrayAsList = new java.util.ArrayList  ();
3589    for(int i = 0; i < filterValues.length; i++) {
3590      arrayAsList.add(
3591        filterValues[i]
3592      );
3593    }
3594    forAllUserDate4 (
3595      operator,
3596      arrayAsList
3597    );
3598  }
3599
3600  public void thereExistsUserDate4 (
3601    short operator,
3602    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3603  ) {
3604    java.util.List   arrayAsList = new java.util.ArrayList  ();
3605    for(int i = 0; i < filterValues.length; i++) {
3606      arrayAsList.add(
3607        filterValues[i]
3608      );
3609    }
3610    thereExistsUserDate4 (
3611      operator,
3612      arrayAsList
3613    );
3614  }
3615
3616  public void orderByUserDate4 (
3617    short order
3618  ) {
3619    refAddValue(
3620      "org:opencrx:kernel:generic:CrxObject:userDate4",
3621      order
3622    );
3623  }
3624      
3625// ----------------------------------------------------------------------------
3626// Filter/ImplAttributeIsNotStruct
3627// ----------------------------------------------------------------------------
3628  public void forAllUserDateTime0 (
3629    short operator,
3630    java.util.Collection   values
3631  ) {
3632    refAddValue(
3633      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3634      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3635      operator,
3636      values
3637    );
3638  }
3639
3640  public void thereExistsUserDateTime0 (
3641    short operator,
3642    java.util.Collection   values
3643  ) {
3644    refAddValue(
3645      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3646      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3647      operator,
3648      values
3649    );
3650  }
3651
3652  public void forAllUserDateTime0 (
3653    short operator,
3654    java.util.Date  [] filterValues
3655  ) {
3656    java.util.List   arrayAsList = new java.util.ArrayList  ();
3657    for(int i = 0; i < filterValues.length; i++) {
3658      arrayAsList.add(
3659        filterValues[i]
3660      );
3661    }
3662    forAllUserDateTime0 (
3663      operator,
3664      arrayAsList
3665    );
3666  }
3667
3668  public void thereExistsUserDateTime0 (
3669    short operator,
3670    java.util.Date  [] filterValues
3671  ) {
3672    java.util.List   arrayAsList = new java.util.ArrayList  ();
3673    for(int i = 0; i < filterValues.length; i++) {
3674      arrayAsList.add(
3675        filterValues[i]
3676      );
3677    }
3678    thereExistsUserDateTime0 (
3679      operator,
3680      arrayAsList
3681    );
3682  }
3683
3684  public void orderByUserDateTime0 (
3685    short order
3686  ) {
3687    refAddValue(
3688      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3689      order
3690    );
3691  }
3692      
3693// ----------------------------------------------------------------------------
3694// Filter/ImplAttributeIsNotStruct
3695// ----------------------------------------------------------------------------
3696  public void forAllUserDateTime1 (
3697    short operator,
3698    java.util.Collection   values
3699  ) {
3700    refAddValue(
3701      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3702      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3703      operator,
3704      values
3705    );
3706  }
3707
3708  public void thereExistsUserDateTime1 (
3709    short operator,
3710    java.util.Collection   values
3711  ) {
3712    refAddValue(
3713      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3714      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3715      operator,
3716      values
3717    );
3718  }
3719
3720  public void forAllUserDateTime1 (
3721    short operator,
3722    java.util.Date  [] filterValues
3723  ) {
3724    java.util.List   arrayAsList = new java.util.ArrayList  ();
3725    for(int i = 0; i < filterValues.length; i++) {
3726      arrayAsList.add(
3727        filterValues[i]
3728      );
3729    }
3730    forAllUserDateTime1 (
3731      operator,
3732      arrayAsList
3733    );
3734  }
3735
3736  public void thereExistsUserDateTime1 (
3737    short operator,
3738    java.util.Date  [] filterValues
3739  ) {
3740    java.util.List   arrayAsList = new java.util.ArrayList  ();
3741    for(int i = 0; i < filterValues.length; i++) {
3742      arrayAsList.add(
3743        filterValues[i]
3744      );
3745    }
3746    thereExistsUserDateTime1 (
3747      operator,
3748      arrayAsList
3749    );
3750  }
3751
3752  public void orderByUserDateTime1 (
3753    short order
3754  ) {
3755    refAddValue(
3756      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3757      order
3758    );
3759  }
3760      
3761// ----------------------------------------------------------------------------
3762// Filter/ImplAttributeIsNotStruct
3763// ----------------------------------------------------------------------------
3764  public void forAllUserDateTime2 (
3765    short operator,
3766    java.util.Collection   values
3767  ) {
3768    refAddValue(
3769      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3770      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3771      operator,
3772      values
3773    );
3774  }
3775
3776  public void thereExistsUserDateTime2 (
3777    short operator,
3778    java.util.Collection   values
3779  ) {
3780    refAddValue(
3781      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3782      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3783      operator,
3784      values
3785    );
3786  }
3787
3788  public void forAllUserDateTime2 (
3789    short operator,
3790    java.util.Date  [] filterValues
3791  ) {
3792    java.util.List   arrayAsList = new java.util.ArrayList  ();
3793    for(int i = 0; i < filterValues.length; i++) {
3794      arrayAsList.add(
3795        filterValues[i]
3796      );
3797    }
3798    forAllUserDateTime2 (
3799      operator,
3800      arrayAsList
3801    );
3802  }
3803
3804  public void thereExistsUserDateTime2 (
3805    short operator,
3806    java.util.Date  [] filterValues
3807  ) {
3808    java.util.List   arrayAsList = new java.util.ArrayList  ();
3809    for(int i = 0; i < filterValues.length; i++) {
3810      arrayAsList.add(
3811        filterValues[i]
3812      );
3813    }
3814    thereExistsUserDateTime2 (
3815      operator,
3816      arrayAsList
3817    );
3818  }
3819
3820  public void orderByUserDateTime2 (
3821    short order
3822  ) {
3823    refAddValue(
3824      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3825      order
3826    );
3827  }
3828      
3829// ----------------------------------------------------------------------------
3830// Filter/ImplAttributeIsNotStruct
3831// ----------------------------------------------------------------------------
3832  public void forAllUserDateTime3 (
3833    short operator,
3834    java.util.Collection   values
3835  ) {
3836    refAddValue(
3837      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3838      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3839      operator,
3840      values
3841    );
3842  }
3843
3844  public void thereExistsUserDateTime3 (
3845    short operator,
3846    java.util.Collection   values
3847  ) {
3848    refAddValue(
3849      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3850      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3851      operator,
3852      values
3853    );
3854  }
3855
3856  public void forAllUserDateTime3 (
3857    short operator,
3858    java.util.Date  [] filterValues
3859  ) {
3860    java.util.List   arrayAsList = new java.util.ArrayList  ();
3861    for(int i = 0; i < filterValues.length; i++) {
3862      arrayAsList.add(
3863        filterValues[i]
3864      );
3865    }
3866    forAllUserDateTime3 (
3867      operator,
3868      arrayAsList
3869    );
3870  }
3871
3872  public void thereExistsUserDateTime3 (
3873    short operator,
3874    java.util.Date  [] filterValues
3875  ) {
3876    java.util.List   arrayAsList = new java.util.ArrayList  ();
3877    for(int i = 0; i < filterValues.length; i++) {
3878      arrayAsList.add(
3879        filterValues[i]
3880      );
3881    }
3882    thereExistsUserDateTime3 (
3883      operator,
3884      arrayAsList
3885    );
3886  }
3887
3888  public void orderByUserDateTime3 (
3889    short order
3890  ) {
3891    refAddValue(
3892      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3893      order
3894    );
3895  }
3896      
3897// ----------------------------------------------------------------------------
3898// Filter/ImplAttributeIsNotStruct
3899// ----------------------------------------------------------------------------
3900  public void forAllUserDateTime4 (
3901    short operator,
3902    java.util.Collection   values
3903  ) {
3904    refAddValue(
3905      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3906      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3907      operator,
3908      values
3909    );
3910  }
3911
3912  public void thereExistsUserDateTime4 (
3913    short operator,
3914    java.util.Collection   values
3915  ) {
3916    refAddValue(
3917      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3918      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3919      operator,
3920      values
3921    );
3922  }
3923
3924  public void forAllUserDateTime4 (
3925    short operator,
3926    java.util.Date  [] filterValues
3927  ) {
3928    java.util.List   arrayAsList = new java.util.ArrayList  ();
3929    for(int i = 0; i < filterValues.length; i++) {
3930      arrayAsList.add(
3931        filterValues[i]
3932      );
3933    }
3934    forAllUserDateTime4 (
3935      operator,
3936      arrayAsList
3937    );
3938  }
3939
3940  public void thereExistsUserDateTime4 (
3941    short operator,
3942    java.util.Date  [] filterValues
3943  ) {
3944    java.util.List   arrayAsList = new java.util.ArrayList  ();
3945    for(int i = 0; i < filterValues.length; i++) {
3946      arrayAsList.add(
3947        filterValues[i]
3948      );
3949    }
3950    thereExistsUserDateTime4 (
3951      operator,
3952      arrayAsList
3953    );
3954  }
3955
3956  public void orderByUserDateTime4 (
3957    short order
3958  ) {
3959    refAddValue(
3960      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3961      order
3962    );
3963  }
3964      
3965// ----------------------------------------------------------------------------
3966// Filter/ImplAttributeIsNotStruct
3967// ----------------------------------------------------------------------------
3968  public void forAllUserNumber0 (
3969    short operator,
3970    java.util.Collection   values
3971  ) {
3972    refAddValue(
3973      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3974      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3975      operator,
3976      values
3977    );
3978  }
3979
3980  public void thereExistsUserNumber0 (
3981    short operator,
3982    java.util.Collection   values
3983  ) {
3984    refAddValue(
3985      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3986      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3987      operator,
3988      values
3989    );
3990  }
3991
3992  public void forAllUserNumber0 (
3993    short operator,
3994    java.math.BigDecimal  [] filterValues
3995  ) {
3996    java.util.List   arrayAsList = new java.util.ArrayList  ();
3997    for(int i = 0; i < filterValues.length; i++) {
3998      arrayAsList.add(
3999        filterValues[i]
4000      );
4001    }
4002    forAllUserNumber0 (
4003      operator,
4004      arrayAsList
4005    );
4006  }
4007
4008  public void thereExistsUserNumber0 (
4009    short operator,
4010    java.math.BigDecimal  [] filterValues
4011  ) {
4012    java.util.List   arrayAsList = new java.util.ArrayList  ();
4013    for(int i = 0; i < filterValues.length; i++) {
4014      arrayAsList.add(
4015        filterValues[i]
4016      );
4017    }
4018    thereExistsUserNumber0 (
4019      operator,
4020      arrayAsList
4021    );
4022  }
4023
4024  public void orderByUserNumber0 (
4025    short order
4026  ) {
4027    refAddValue(
4028      "org:opencrx:kernel:generic:CrxObject:userNumber0",
4029      order
4030    );
4031  }
4032      
4033// ----------------------------------------------------------------------------
4034// Filter/ImplAttributeIsNotStruct
4035// ----------------------------------------------------------------------------
4036  public void forAllUserNumber1 (
4037    short operator,
4038    java.util.Collection   values
4039  ) {
4040    refAddValue(
4041      "org:opencrx:kernel:generic:CrxObject:userNumber1",
4042      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4043      operator,
4044      values
4045    );
4046  }
4047
4048  public void thereExistsUserNumber1 (
4049    short operator,
4050    java.util.Collection   values
4051  ) {
4052    refAddValue(
4053      "org:opencrx:kernel:generic:CrxObject:userNumber1",
4054      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4055      operator,
4056      values
4057    );
4058  }
4059
4060  public void forAllUserNumber1 (
4061    short operator,
4062    java.math.BigDecimal  [] filterValues
4063  ) {
4064    java.util.List   arrayAsList = new java.util.ArrayList  ();
4065    for(int i = 0; i < filterValues.length; i++) {
4066      arrayAsList.add(
4067        filterValues[i]
4068      );
4069    }
4070    forAllUserNumber1 (
4071      operator,
4072      arrayAsList
4073    );
4074  }
4075
4076  public void thereExistsUserNumber1 (
4077    short operator,
4078    java.math.BigDecimal  [] filterValues
4079  ) {
4080    java.util.List   arrayAsList = new java.util.ArrayList  ();
4081    for(int i = 0; i < filterValues.length; i++) {
4082      arrayAsList.add(
4083        filterValues[i]
4084      );
4085    }
4086    thereExistsUserNumber1 (
4087      operator,
4088      arrayAsList
4089    );
4090  }
4091
4092  public void orderByUserNumber1 (
4093    short order
4094  ) {
4095    refAddValue(
4096      "org:opencrx:kernel:generic:CrxObject:userNumber1",
4097      order
4098    );
4099  }
4100      
4101// ----------------------------------------------------------------------------
4102// Filter/ImplAttributeIsNotStruct
4103// ----------------------------------------------------------------------------
4104  public void forAllUserNumber2 (
4105    short operator,
4106    java.util.Collection   values
4107  ) {
4108    refAddValue(
4109      "org:opencrx:kernel:generic:CrxObject:userNumber2",
4110      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4111      operator,
4112      values
4113    );
4114  }
4115
4116  public void thereExistsUserNumber2 (
4117    short operator,
4118    java.util.Collection   values
4119  ) {
4120    refAddValue(
4121      "org:opencrx:kernel:generic:CrxObject:userNumber2",
4122      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4123      operator,
4124      values
4125    );
4126  }
4127
4128  public void forAllUserNumber2 (
4129    short operator,
4130    java.math.BigDecimal  [] filterValues
4131  ) {
4132    java.util.List   arrayAsList = new java.util.ArrayList  ();
4133    for(int i = 0; i < filterValues.length; i++) {
4134      arrayAsList.add(
4135        filterValues[i]
4136      );
4137    }
4138    forAllUserNumber2 (
4139      operator,
4140      arrayAsList
4141    );
4142  }
4143
4144  public void thereExistsUserNumber2 (
4145    short operator,
4146    java.math.BigDecimal  [] filterValues
4147  ) {
4148    java.util.List   arrayAsList = new java.util.ArrayList  ();
4149    for(int i = 0; i < filterValues.length; i++) {
4150      arrayAsList.add(
4151        filterValues[i]
4152      );
4153    }
4154    thereExistsUserNumber2 (
4155      operator,
4156      arrayAsList
4157    );
4158  }
4159
4160  public void orderByUserNumber2 (
4161    short order
4162  ) {
4163    refAddValue(
4164      "org:opencrx:kernel:generic:CrxObject:userNumber2",
4165      order
4166    );
4167  }
4168      
4169// ----------------------------------------------------------------------------
4170// Filter/ImplAttributeIsNotStruct
4171// ----------------------------------------------------------------------------
4172  public void forAllUserNumber3 (
4173    short operator,
4174    java.util.Collection   values
4175  ) {
4176    refAddValue(
4177      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4178      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4179      operator,
4180      values
4181    );
4182  }
4183
4184  public void thereExistsUserNumber3 (
4185    short operator,
4186    java.util.Collection   values
4187  ) {
4188    refAddValue(
4189      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4190      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4191      operator,
4192      values
4193    );
4194  }
4195
4196  public void forAllUserNumber3 (
4197    short operator,
4198    java.math.BigDecimal  [] filterValues
4199  ) {
4200    java.util.List   arrayAsList = new java.util.ArrayList  ();
4201    for(int i = 0; i < filterValues.length; i++) {
4202      arrayAsList.add(
4203        filterValues[i]
4204      );
4205    }
4206    forAllUserNumber3 (
4207      operator,
4208      arrayAsList
4209    );
4210  }
4211
4212  public void thereExistsUserNumber3 (
4213    short operator,
4214    java.math.BigDecimal  [] filterValues
4215  ) {
4216    java.util.List   arrayAsList = new java.util.ArrayList  ();
4217    for(int i = 0; i < filterValues.length; i++) {
4218      arrayAsList.add(
4219        filterValues[i]
4220      );
4221    }
4222    thereExistsUserNumber3 (
4223      operator,
4224      arrayAsList
4225    );
4226  }
4227
4228  public void orderByUserNumber3 (
4229    short order
4230  ) {
4231    refAddValue(
4232      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4233      order
4234    );
4235  }
4236      
4237// ----------------------------------------------------------------------------
4238// Filter/ImplAttributeIsNotStruct
4239// ----------------------------------------------------------------------------
4240  public void forAllUserNumber4 (
4241    short operator,
4242    java.util.Collection   values
4243  ) {
4244    refAddValue(
4245      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4246      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4247      operator,
4248      values
4249    );
4250  }
4251
4252  public void thereExistsUserNumber4 (
4253    short operator,
4254    java.util.Collection   values
4255  ) {
4256    refAddValue(
4257      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4258      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4259      operator,
4260      values
4261    );
4262  }
4263
4264  public void forAllUserNumber4 (
4265    short operator,
4266    java.math.BigDecimal  [] filterValues
4267  ) {
4268    java.util.List   arrayAsList = new java.util.ArrayList  ();
4269    for(int i = 0; i < filterValues.length; i++) {
4270      arrayAsList.add(
4271        filterValues[i]
4272      );
4273    }
4274    forAllUserNumber4 (
4275      operator,
4276      arrayAsList
4277    );
4278  }
4279
4280  public void thereExistsUserNumber4 (
4281    short operator,
4282    java.math.BigDecimal  [] filterValues
4283  ) {
4284    java.util.List   arrayAsList = new java.util.ArrayList  ();
4285    for(int i = 0; i < filterValues.length; i++) {
4286      arrayAsList.add(
4287        filterValues[i]
4288      );
4289    }
4290    thereExistsUserNumber4 (
4291      operator,
4292      arrayAsList
4293    );
4294  }
4295
4296  public void orderByUserNumber4 (
4297    short order
4298  ) {
4299    refAddValue(
4300      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4301      order
4302    );
4303  }
4304      
4305// ----------------------------------------------------------------------------
4306// Filter/ImplAttributeIsNotStruct
4307// ----------------------------------------------------------------------------
4308  public void forAllUserString0 (
4309    short operator,
4310    java.util.Collection   values
4311  ) {
4312    refAddValue(
4313      "org:opencrx:kernel:generic:CrxObject:userString0",
4314      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4315      operator,
4316      values
4317    );
4318  }
4319
4320  public void thereExistsUserString0 (
4321    short operator,
4322    java.util.Collection   values
4323  ) {
4324    refAddValue(
4325      "org:opencrx:kernel:generic:CrxObject:userString0",
4326      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4327      operator,
4328      values
4329    );
4330  }
4331
4332  public void forAllUserString0 (
4333    short operator,
4334    String  [] filterValues
4335  ) {
4336    java.util.List   arrayAsList = new java.util.ArrayList  ();
4337    for(int i = 0; i < filterValues.length; i++) {
4338      arrayAsList.add(
4339        filterValues[i]
4340      );
4341    }
4342    forAllUserString0 (
4343      operator,
4344      arrayAsList
4345    );
4346  }
4347
4348  public void thereExistsUserString0 (
4349    short operator,
4350    String  [] filterValues
4351  ) {
4352    java.util.List   arrayAsList = new java.util.ArrayList  ();
4353    for(int i = 0; i < filterValues.length; i++) {
4354      arrayAsList.add(
4355        filterValues[i]
4356      );
4357    }
4358    thereExistsUserString0 (
4359      operator,
4360      arrayAsList
4361    );
4362  }
4363
4364  public void orderByUserString0 (
4365    short order
4366  ) {
4367    refAddValue(
4368      "org:opencrx:kernel:generic:CrxObject:userString0",
4369      order
4370    );
4371  }
4372      
4373// ----------------------------------------------------------------------------
4374// Filter/ImplAttributeIsNotStruct
4375// ----------------------------------------------------------------------------
4376  public void forAllUserString1 (
4377    short operator,
4378    java.util.Collection   values
4379  ) {
4380    refAddValue(
4381      "org:opencrx:kernel:generic:CrxObject:userString1",
4382      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4383      operator,
4384      values
4385    );
4386  }
4387
4388  public void thereExistsUserString1 (
4389    short operator,
4390    java.util.Collection   values
4391  ) {
4392    refAddValue(
4393      "org:opencrx:kernel:generic:CrxObject:userString1",
4394      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4395      operator,
4396      values
4397    );
4398  }
4399
4400  public void forAllUserString1 (
4401    short operator,
4402    String  [] filterValues
4403  ) {
4404    java.util.List   arrayAsList = new java.util.ArrayList  ();
4405    for(int i = 0; i < filterValues.length; i++) {
4406      arrayAsList.add(
4407        filterValues[i]
4408      );
4409    }
4410    forAllUserString1 (
4411      operator,
4412      arrayAsList
4413    );
4414  }
4415
4416  public void thereExistsUserString1 (
4417    short operator,
4418    String  [] filterValues
4419  ) {
4420    java.util.List   arrayAsList = new java.util.ArrayList  ();
4421    for(int i = 0; i < filterValues.length; i++) {
4422      arrayAsList.add(
4423        filterValues[i]
4424      );
4425    }
4426    thereExistsUserString1 (
4427      operator,
4428      arrayAsList
4429    );
4430  }
4431
4432  public void orderByUserString1 (
4433    short order
4434  ) {
4435    refAddValue(
4436      "org:opencrx:kernel:generic:CrxObject:userString1",
4437      order
4438    );
4439  }
4440      
4441// ----------------------------------------------------------------------------
4442// Filter/ImplAttributeIsNotStruct
4443// ----------------------------------------------------------------------------
4444  public void forAllUserString2 (
4445    short operator,
4446    java.util.Collection   values
4447  ) {
4448    refAddValue(
4449      "org:opencrx:kernel:generic:CrxObject:userString2",
4450      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4451      operator,
4452      values
4453    );
4454  }
4455
4456  public void thereExistsUserString2 (
4457    short operator,
4458    java.util.Collection   values
4459  ) {
4460    refAddValue(
4461      "org:opencrx:kernel:generic:CrxObject:userString2",
4462      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4463      operator,
4464      values
4465    );
4466  }
4467
4468  public void forAllUserString2 (
4469    short operator,
4470    String  [] filterValues
4471  ) {
4472    java.util.List   arrayAsList = new java.util.ArrayList  ();
4473    for(int i = 0; i < filterValues.length; i++) {
4474      arrayAsList.add(
4475        filterValues[i]
4476      );
4477    }
4478    forAllUserString2 (
4479      operator,
4480      arrayAsList
4481    );
4482  }
4483
4484  public void thereExistsUserString2 (
4485    short operator,
4486    String  [] filterValues
4487  ) {
4488    java.util.List   arrayAsList = new java.util.ArrayList  ();
4489    for(int i = 0; i < filterValues.length; i++) {
4490      arrayAsList.add(
4491        filterValues[i]
4492      );
4493    }
4494    thereExistsUserString2 (
4495      operator,
4496      arrayAsList
4497    );
4498  }
4499
4500  public void orderByUserString2 (
4501    short order
4502  ) {
4503    refAddValue(
4504      "org:opencrx:kernel:generic:CrxObject:userString2",
4505      order
4506    );
4507  }
4508      
4509// ----------------------------------------------------------------------------
4510// Filter/ImplAttributeIsNotStruct
4511// ----------------------------------------------------------------------------
4512  public void forAllUserString3 (
4513    short operator,
4514    java.util.Collection   values
4515  ) {
4516    refAddValue(
4517      "org:opencrx:kernel:generic:CrxObject:userString3",
4518      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4519      operator,
4520      values
4521    );
4522  }
4523
4524  public void thereExistsUserString3 (
4525    short operator,
4526    java.util.Collection   values
4527  ) {
4528    refAddValue(
4529      "org:opencrx:kernel:generic:CrxObject:userString3",
4530      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4531      operator,
4532      values
4533    );
4534  }
4535
4536  public void forAllUserString3 (
4537    short operator,
4538    String  [] filterValues
4539  ) {
4540    java.util.List   arrayAsList = new java.util.ArrayList  ();
4541    for(int i = 0; i < filterValues.length; i++) {
4542      arrayAsList.add(
4543        filterValues[i]
4544      );
4545    }
4546    forAllUserString3 (
4547      operator,
4548      arrayAsList
4549    );
4550  }
4551
4552  public void thereExistsUserString3 (
4553    short operator,
4554    String  [] filterValues
4555  ) {
4556    java.util.List   arrayAsList = new java.util.ArrayList  ();
4557    for(int i = 0; i < filterValues.length; i++) {
4558      arrayAsList.add(
4559        filterValues[i]
4560      );
4561    }
4562    thereExistsUserString3 (
4563      operator,
4564      arrayAsList
4565    );
4566  }
4567
4568  public void orderByUserString3 (
4569    short order
4570  ) {
4571    refAddValue(
4572      "org:opencrx:kernel:generic:CrxObject:userString3",
4573      order
4574    );
4575  }
4576      
4577// ----------------------------------------------------------------------------
4578// Filter/ImplAttributeIsNotStruct
4579// ----------------------------------------------------------------------------
4580  public void forAllUserString4 (
4581    short operator,
4582    java.util.Collection   values
4583  ) {
4584    refAddValue(
4585      "org:opencrx:kernel:generic:CrxObject:userString4",
4586      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4587      operator,
4588      values
4589    );
4590  }
4591
4592  public void thereExistsUserString4 (
4593    short operator,
4594    java.util.Collection   values
4595  ) {
4596    refAddValue(
4597      "org:opencrx:kernel:generic:CrxObject:userString4",
4598      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4599      operator,
4600      values
4601    );
4602  }
4603
4604  public void forAllUserString4 (
4605    short operator,
4606    String  [] filterValues
4607  ) {
4608    java.util.List   arrayAsList = new java.util.ArrayList  ();
4609    for(int i = 0; i < filterValues.length; i++) {
4610      arrayAsList.add(
4611        filterValues[i]
4612      );
4613    }
4614    forAllUserString4 (
4615      operator,
4616      arrayAsList
4617    );
4618  }
4619
4620  public void thereExistsUserString4 (
4621    short operator,
4622    String  [] filterValues
4623  ) {
4624    java.util.List   arrayAsList = new java.util.ArrayList  ();
4625    for(int i = 0; i < filterValues.length; i++) {
4626      arrayAsList.add(
4627        filterValues[i]
4628      );
4629    }
4630    thereExistsUserString4 (
4631      operator,
4632      arrayAsList
4633    );
4634  }
4635
4636  public void orderByUserString4 (
4637    short order
4638  ) {
4639    refAddValue(
4640      "org:opencrx:kernel:generic:CrxObject:userString4",
4641      order
4642    );
4643  }
4644      
4645// ----------------------------------------------------------------------------
4646// Filter/ImplAttributeIsNotStruct
4647// ----------------------------------------------------------------------------
4648  public void forAllCreatedAt (
4649    short operator,
4650    java.util.Collection   values
4651  ) {
4652    refAddValue(
4653      "org:openmdx:base:BasicObject:createdAt",
4654      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4655      operator,
4656      values
4657    );
4658  }
4659
4660  public void thereExistsCreatedAt (
4661    short operator,
4662    java.util.Collection   values
4663  ) {
4664    refAddValue(
4665      "org:openmdx:base:BasicObject:createdAt",
4666      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4667      operator,
4668      values
4669    );
4670  }
4671
4672  public void forAllCreatedAt (
4673    short operator,
4674    java.util.Date  [] filterValues
4675  ) {
4676    java.util.List   arrayAsList = new java.util.ArrayList  ();
4677    for(int i = 0; i < filterValues.length; i++) {
4678      arrayAsList.add(
4679        filterValues[i]
4680      );
4681    }
4682    forAllCreatedAt (
4683      operator,
4684      arrayAsList
4685    );
4686  }
4687
4688  public void thereExistsCreatedAt (
4689    short operator,
4690    java.util.Date  [] filterValues
4691  ) {
4692    java.util.List   arrayAsList = new java.util.ArrayList  ();
4693    for(int i = 0; i < filterValues.length; i++) {
4694      arrayAsList.add(
4695        filterValues[i]
4696      );
4697    }
4698    thereExistsCreatedAt (
4699      operator,
4700      arrayAsList
4701    );
4702  }
4703
4704  public void orderByCreatedAt (
4705    short order
4706  ) {
4707    refAddValue(
4708      "org:openmdx:base:BasicObject:createdAt",
4709      order
4710    );
4711  }
4712      
4713// ----------------------------------------------------------------------------
4714// Filter/ImplAttributeIsNotStruct
4715// ----------------------------------------------------------------------------
4716  public void forAllCreatedBy (
4717    short operator,
4718    java.util.Collection   values
4719  ) {
4720    refAddValue(
4721      "org:openmdx:base:BasicObject:createdBy",
4722      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4723      operator,
4724      values
4725    );
4726  }
4727
4728  public void thereExistsCreatedBy (
4729    short operator,
4730    java.util.Collection   values
4731  ) {
4732    refAddValue(
4733      "org:openmdx:base:BasicObject:createdBy",
4734      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4735      operator,
4736      values
4737    );
4738  }
4739
4740  public void forAllCreatedBy (
4741    short operator,
4742    String  [] filterValues
4743  ) {
4744    java.util.List   arrayAsList = new java.util.ArrayList  ();
4745    for(int i = 0; i < filterValues.length; i++) {
4746      arrayAsList.add(
4747        filterValues[i]
4748      );
4749    }
4750    forAllCreatedBy (
4751      operator,
4752      arrayAsList
4753    );
4754  }
4755
4756  public void thereExistsCreatedBy (
4757    short operator,
4758    String  [] filterValues
4759  ) {
4760    java.util.List   arrayAsList = new java.util.ArrayList  ();
4761    for(int i = 0; i < filterValues.length; i++) {
4762      arrayAsList.add(
4763        filterValues[i]
4764      );
4765    }
4766    thereExistsCreatedBy (
4767      operator,
4768      arrayAsList
4769    );
4770  }
4771
4772  public void orderByCreatedBy (
4773    short order
4774  ) {
4775    refAddValue(
4776      "org:openmdx:base:BasicObject:createdBy",
4777      order
4778    );
4779  }
4780      
4781// ----------------------------------------------------------------------------
4782// Filter/ImplAttributeIsNotStruct
4783// ----------------------------------------------------------------------------
4784  public void forAllModifiedAt (
4785    short operator,
4786    java.util.Collection   values
4787  ) {
4788    refAddValue(
4789      "org:openmdx:base:BasicObject:modifiedAt",
4790      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4791      operator,
4792      values
4793    );
4794  }
4795
4796  public void thereExistsModifiedAt (
4797    short operator,
4798    java.util.Collection   values
4799  ) {
4800    refAddValue(
4801      "org:openmdx:base:BasicObject:modifiedAt",
4802      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4803      operator,
4804      values
4805    );
4806  }
4807
4808  public void forAllModifiedAt (
4809    short operator,
4810    java.util.Date  [] 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    forAllModifiedAt (
4819      operator,
4820      arrayAsList
4821    );
4822  }
4823
4824  public void thereExistsModifiedAt (
4825    short operator,
4826    java.util.Date  [] 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    thereExistsModifiedAt (
4835      operator,
4836      arrayAsList
4837    );
4838  }
4839
4840  public void orderByModifiedAt (
4841    short order
4842  ) {
4843    refAddValue(
4844      "org:openmdx:base:BasicObject:modifiedAt",
4845      order
4846    );
4847  }
4848      
4849// ----------------------------------------------------------------------------
4850// Filter/ImplAttributeIsNotStruct
4851// ----------------------------------------------------------------------------
4852  public void forAllModifiedBy (
4853    short operator,
4854    java.util.Collection   values
4855  ) {
4856    refAddValue(
4857      "org:openmdx:base:BasicObject:modifiedBy",
4858      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4859      operator,
4860      values
4861    );
4862  }
4863
4864  public void thereExistsModifiedBy (
4865    short operator,
4866    java.util.Collection   values
4867  ) {
4868    refAddValue(
4869      "org:openmdx:base:BasicObject:modifiedBy",
4870      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4871      operator,
4872      values
4873    );
4874  }
4875
4876  public void forAllModifiedBy (
4877    short operator,
4878    String  [] filterValues
4879  ) {
4880    java.util.List   arrayAsList = new java.util.ArrayList  ();
4881    for(int i = 0; i < filterValues.length; i++) {
4882      arrayAsList.add(
4883        filterValues[i]
4884      );
4885    }
4886    forAllModifiedBy (
4887      operator,
4888      arrayAsList
4889    );
4890  }
4891
4892  public void thereExistsModifiedBy (
4893    short operator,
4894    String  [] filterValues
4895  ) {
4896    java.util.List   arrayAsList = new java.util.ArrayList  ();
4897    for(int i = 0; i < filterValues.length; i++) {
4898      arrayAsList.add(
4899        filterValues[i]
4900      );
4901    }
4902    thereExistsModifiedBy (
4903      operator,
4904      arrayAsList
4905    );
4906  }
4907
4908  public void orderByModifiedBy (
4909    short order
4910  ) {
4911    refAddValue(
4912      "org:openmdx:base:BasicObject:modifiedBy",
4913      order
4914    );
4915  }
4916      
4917// ----------------------------------------------------------------------------
4918// Filter/ImplReference
4919// ----------------------------------------------------------------------------
4920  public void forAllContext (
4921    short operator,
4922    org.openmdx.base.cci.Context[] filterValues
4923  ) {
4924    java.util.List   arrayAsList = new java.util.ArrayList  ();
4925    for(int i = 0; i < filterValues.length; i++) {
4926      arrayAsList.add(
4927        filterValues[i]
4928      );
4929    }
4930    forAllContext (
4931      operator,
4932      arrayAsList
4933    );
4934  }
4935
4936  public void thereExistsContext (
4937    short operator,
4938    org.openmdx.base.cci.Context[] filterValues
4939  ) {
4940    java.util.List   arrayAsList = new java.util.ArrayList  ();
4941    for(int i = 0; i < filterValues.length; i++) {
4942      arrayAsList.add(
4943        filterValues[i]
4944      );
4945    }
4946    thereExistsContext (
4947      operator,
4948      arrayAsList
4949    );
4950  }
4951
4952  public void forAllContext (
4953    short operator,
4954    java.util.Collection   values
4955  ) {
4956    refAddValue(
4957      "org:openmdx:base:ContextCapable:context",
4958      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4959      operator,
4960      values
4961    );
4962  }
4963
4964  public void thereExistsContext (
4965    short operator,
4966    java.util.Collection   values
4967  ) {
4968    refAddValue(
4969      "org:openmdx:base:ContextCapable:context",
4970      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4971      operator,
4972      values
4973    );
4974  }
4975      
4976// ----------------------------------------------------------------------------
4977// Filter/ImplAttributeIsNotStruct
4978// ----------------------------------------------------------------------------
4979  public void forAllIdentity (
4980    short operator,
4981    java.util.Collection   values
4982  ) {
4983    refAddValue(
4984      "org:openmdx:base:ExtentCapable:identity",
4985      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4986      operator,
4987      values
4988    );
4989  }
4990
4991  public void thereExistsIdentity (
4992    short operator,
4993    java.util.Collection   values
4994  ) {
4995    refAddValue(
4996      "org:openmdx:base:ExtentCapable:identity",
4997      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4998      operator,
4999      values
5000    );
5001  }
5002
5003  public void forAllIdentity (
5004    short operator,
5005    String  [] filterValues
5006  ) {
5007    java.util.List   arrayAsList = new java.util.ArrayList  ();
5008    for(int i = 0; i < filterValues.length; i++) {
5009      arrayAsList.add(
5010        filterValues[i]
5011      );
5012    }
5013    forAllIdentity (
5014      operator,
5015      arrayAsList
5016    );
5017  }
5018
5019  public void thereExistsIdentity (
5020    short operator,
5021    String  [] filterValues
5022  ) {
5023    java.util.List   arrayAsList = new java.util.ArrayList  ();
5024    for(int i = 0; i < filterValues.length; i++) {
5025      arrayAsList.add(
5026        filterValues[i]
5027      );
5028    }
5029    thereExistsIdentity (
5030      operator,
5031      arrayAsList
5032    );
5033  }
5034
5035  public void orderByIdentity (
5036    short order
5037  ) {
5038    refAddValue(
5039      "org:openmdx:base:ExtentCapable:identity",
5040      order
5041    );
5042  }
5043      
5044// ----------------------------------------------------------------------------
5045// Filter/ImplEnd
5046// ----------------------------------------------------------------------------
5047}        
5048
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags