PhoneCallFilterImpl


1   // ----------------------------------------------------------------------------
2   // Filter/ImplBegin
3   // ----------------------------------------------------------------------------
4   //////////////////////////////////////////////////////////////////////////////
5   //
6   // Name: $Id: JMIAbstractMapper.java,v 1.11 2006/01/21 23:09:07 wfro Exp $
7   // Generated by: openMDX JMI Mapper
8   // Date: Mon Apr 03 11:39:03 CEST 2006
9   //
10  // GENERATED - DO NOT CHANGE MANUALLY
11  //
12  //////////////////////////////////////////////////////////////////////////////
13  package org.opencrx.kernel.activity1.cci;
14  
15  public class PhoneCallFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements PhoneCallFilter {
18  
19    public PhoneCallFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:activity1:PhoneCall",
25        null,
26        null
27      );
28    }
29  
30    public PhoneCallFilterImpl(
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:PhoneCall",
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/ImplReference
1750// ----------------------------------------------------------------------------
1751  public void forAllSender (
1752    short operator,
1753    org.opencrx.kernel.account1.cci.PhoneNumber[] filterValues
1754  ) {
1755    java.util.List   arrayAsList = new java.util.ArrayList  ();
1756    for(int i = 0; i < filterValues.length; i++) {
1757      arrayAsList.add(
1758        filterValues[i]
1759      );
1760    }
1761    forAllSender (
1762      operator,
1763      arrayAsList
1764    );
1765  }
1766
1767  public void thereExistsSender (
1768    short operator,
1769    org.opencrx.kernel.account1.cci.PhoneNumber[] filterValues
1770  ) {
1771    java.util.List   arrayAsList = new java.util.ArrayList  ();
1772    for(int i = 0; i < filterValues.length; i++) {
1773      arrayAsList.add(
1774        filterValues[i]
1775      );
1776    }
1777    thereExistsSender (
1778      operator,
1779      arrayAsList
1780    );
1781  }
1782
1783  public void forAllSender (
1784    short operator,
1785    java.util.Collection   values
1786  ) {
1787    refAddValue(
1788      "org:opencrx:kernel:activity1:PhoneCall:sender",
1789      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1790      operator,
1791      values
1792    );
1793  }
1794
1795  public void thereExistsSender (
1796    short operator,
1797    java.util.Collection   values
1798  ) {
1799    refAddValue(
1800      "org:opencrx:kernel:activity1:PhoneCall:sender",
1801      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1802      operator,
1803      values
1804    );
1805  }
1806      
1807// ----------------------------------------------------------------------------
1808// Filter/ImplAttributeIsNotStruct
1809// ----------------------------------------------------------------------------
1810  public void forAllAccessLevelBrowse (
1811    short operator,
1812    java.util.Collection   values
1813  ) {
1814    refAddValue(
1815      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1816      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1817      operator,
1818      values
1819    );
1820  }
1821
1822  public void thereExistsAccessLevelBrowse (
1823    short operator,
1824    java.util.Collection   values
1825  ) {
1826    refAddValue(
1827      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1828      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1829      operator,
1830      values
1831    );
1832  }
1833
1834  public void forAllAccessLevelBrowse (
1835    short operator,
1836    short[] filterValues
1837  ) {
1838    java.util.List   arrayAsList = new java.util.ArrayList  ();
1839    for(int i = 0; i < filterValues.length; i++) {
1840      arrayAsList.add(
1841        new Short  (filterValues[i])
1842      );
1843    }
1844    forAllAccessLevelBrowse (
1845      operator,
1846      arrayAsList
1847    );
1848  }
1849
1850  public void thereExistsAccessLevelBrowse (
1851    short operator,
1852    short[] filterValues
1853  ) {
1854    java.util.List   arrayAsList = new java.util.ArrayList  ();
1855    for(int i = 0; i < filterValues.length; i++) {
1856      arrayAsList.add(
1857        new Short  (filterValues[i])
1858      );
1859    }
1860    thereExistsAccessLevelBrowse (
1861      operator,
1862      arrayAsList
1863    );
1864  }
1865
1866  public void orderByAccessLevelBrowse (
1867    short order
1868  ) {
1869    refAddValue(
1870      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1871      order
1872    );
1873  }
1874      
1875// ----------------------------------------------------------------------------
1876// Filter/ImplAttributeIsNotStruct
1877// ----------------------------------------------------------------------------
1878  public void forAllAccessLevelDelete (
1879    short operator,
1880    java.util.Collection   values
1881  ) {
1882    refAddValue(
1883      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1884      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1885      operator,
1886      values
1887    );
1888  }
1889
1890  public void thereExistsAccessLevelDelete (
1891    short operator,
1892    java.util.Collection   values
1893  ) {
1894    refAddValue(
1895      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1896      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1897      operator,
1898      values
1899    );
1900  }
1901
1902  public void forAllAccessLevelDelete (
1903    short operator,
1904    short[] filterValues
1905  ) {
1906    java.util.List   arrayAsList = new java.util.ArrayList  ();
1907    for(int i = 0; i < filterValues.length; i++) {
1908      arrayAsList.add(
1909        new Short  (filterValues[i])
1910      );
1911    }
1912    forAllAccessLevelDelete (
1913      operator,
1914      arrayAsList
1915    );
1916  }
1917
1918  public void thereExistsAccessLevelDelete (
1919    short operator,
1920    short[] filterValues
1921  ) {
1922    java.util.List   arrayAsList = new java.util.ArrayList  ();
1923    for(int i = 0; i < filterValues.length; i++) {
1924      arrayAsList.add(
1925        new Short  (filterValues[i])
1926      );
1927    }
1928    thereExistsAccessLevelDelete (
1929      operator,
1930      arrayAsList
1931    );
1932  }
1933
1934  public void orderByAccessLevelDelete (
1935    short order
1936  ) {
1937    refAddValue(
1938      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1939      order
1940    );
1941  }
1942      
1943// ----------------------------------------------------------------------------
1944// Filter/ImplAttributeIsNotStruct
1945// ----------------------------------------------------------------------------
1946  public void forAllAccessLevelUpdate (
1947    short operator,
1948    java.util.Collection   values
1949  ) {
1950    refAddValue(
1951      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1952      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1953      operator,
1954      values
1955    );
1956  }
1957
1958  public void thereExistsAccessLevelUpdate (
1959    short operator,
1960    java.util.Collection   values
1961  ) {
1962    refAddValue(
1963      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1964      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1965      operator,
1966      values
1967    );
1968  }
1969
1970  public void forAllAccessLevelUpdate (
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    forAllAccessLevelUpdate (
1981      operator,
1982      arrayAsList
1983    );
1984  }
1985
1986  public void thereExistsAccessLevelUpdate (
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    thereExistsAccessLevelUpdate (
1997      operator,
1998      arrayAsList
1999    );
2000  }
2001
2002  public void orderByAccessLevelUpdate (
2003    short order
2004  ) {
2005    refAddValue(
2006      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
2007      order
2008    );
2009  }
2010      
2011// ----------------------------------------------------------------------------
2012// Filter/ImplAttributeIsNotStruct
2013// ----------------------------------------------------------------------------
2014  public void forAllOwner (
2015    short operator,
2016    java.util.Collection   values
2017  ) {
2018    refAddValue(
2019      "org:opencrx:kernel:base:SecureObject:owner",
2020      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2021      operator,
2022      values
2023    );
2024  }
2025
2026  public void thereExistsOwner (
2027    short operator,
2028    java.util.Collection   values
2029  ) {
2030    refAddValue(
2031      "org:opencrx:kernel:base:SecureObject:owner",
2032      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2033      operator,
2034      values
2035    );
2036  }
2037
2038  public void forAllOwner (
2039    short operator,
2040    String  [] filterValues
2041  ) {
2042    java.util.List   arrayAsList = new java.util.ArrayList  ();
2043    for(int i = 0; i < filterValues.length; i++) {
2044      arrayAsList.add(
2045        filterValues[i]
2046      );
2047    }
2048    forAllOwner (
2049      operator,
2050      arrayAsList
2051    );
2052  }
2053
2054  public void thereExistsOwner (
2055    short operator,
2056    String  [] filterValues
2057  ) {
2058    java.util.List   arrayAsList = new java.util.ArrayList  ();
2059    for(int i = 0; i < filterValues.length; i++) {
2060      arrayAsList.add(
2061        filterValues[i]
2062      );
2063    }
2064    thereExistsOwner (
2065      operator,
2066      arrayAsList
2067    );
2068  }
2069
2070  public void orderByOwner (
2071    short order
2072  ) {
2073    refAddValue(
2074      "org:opencrx:kernel:base:SecureObject:owner",
2075      order
2076    );
2077  }
2078      
2079// ----------------------------------------------------------------------------
2080// Filter/ImplReference
2081// ----------------------------------------------------------------------------
2082  public void forAllOwningGroup (
2083    short operator,
2084    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2085  ) {
2086    java.util.List   arrayAsList = new java.util.ArrayList  ();
2087    for(int i = 0; i < filterValues.length; i++) {
2088      arrayAsList.add(
2089        filterValues[i]
2090      );
2091    }
2092    forAllOwningGroup (
2093      operator,
2094      arrayAsList
2095    );
2096  }
2097
2098  public void thereExistsOwningGroup (
2099    short operator,
2100    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
2101  ) {
2102    java.util.List   arrayAsList = new java.util.ArrayList  ();
2103    for(int i = 0; i < filterValues.length; i++) {
2104      arrayAsList.add(
2105        filterValues[i]
2106      );
2107    }
2108    thereExistsOwningGroup (
2109      operator,
2110      arrayAsList
2111    );
2112  }
2113
2114  public void forAllOwningGroup (
2115    short operator,
2116    java.util.Collection   values
2117  ) {
2118    refAddValue(
2119      "org:opencrx:kernel:base:SecureObject:owningGroup",
2120      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2121      operator,
2122      values
2123    );
2124  }
2125
2126  public void thereExistsOwningGroup (
2127    short operator,
2128    java.util.Collection   values
2129  ) {
2130    refAddValue(
2131      "org:opencrx:kernel:base:SecureObject:owningGroup",
2132      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2133      operator,
2134      values
2135    );
2136  }
2137      
2138// ----------------------------------------------------------------------------
2139// Filter/ImplReference
2140// ----------------------------------------------------------------------------
2141  public void forAllOwningUser (
2142    short operator,
2143    org.opencrx.security.realm1.cci.User[] filterValues
2144  ) {
2145    java.util.List   arrayAsList = new java.util.ArrayList  ();
2146    for(int i = 0; i < filterValues.length; i++) {
2147      arrayAsList.add(
2148        filterValues[i]
2149      );
2150    }
2151    forAllOwningUser (
2152      operator,
2153      arrayAsList
2154    );
2155  }
2156
2157  public void thereExistsOwningUser (
2158    short operator,
2159    org.opencrx.security.realm1.cci.User[] filterValues
2160  ) {
2161    java.util.List   arrayAsList = new java.util.ArrayList  ();
2162    for(int i = 0; i < filterValues.length; i++) {
2163      arrayAsList.add(
2164        filterValues[i]
2165      );
2166    }
2167    thereExistsOwningUser (
2168      operator,
2169      arrayAsList
2170    );
2171  }
2172
2173  public void forAllOwningUser (
2174    short operator,
2175    java.util.Collection   values
2176  ) {
2177    refAddValue(
2178      "org:opencrx:kernel:base:SecureObject:owningUser",
2179      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2180      operator,
2181      values
2182    );
2183  }
2184
2185  public void thereExistsOwningUser (
2186    short operator,
2187    java.util.Collection   values
2188  ) {
2189    refAddValue(
2190      "org:opencrx:kernel:base:SecureObject:owningUser",
2191      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2192      operator,
2193      values
2194    );
2195  }
2196      
2197// ----------------------------------------------------------------------------
2198// Filter/ImplAttributeIsNotStruct
2199// ----------------------------------------------------------------------------
2200  public void forAllCategory (
2201    short operator,
2202    java.util.Collection   values
2203  ) {
2204    refAddValue(
2205      "org:opencrx:kernel:generic:CrxObject:category",
2206      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2207      operator,
2208      values
2209    );
2210  }
2211
2212  public void thereExistsCategory (
2213    short operator,
2214    java.util.Collection   values
2215  ) {
2216    refAddValue(
2217      "org:opencrx:kernel:generic:CrxObject:category",
2218      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2219      operator,
2220      values
2221    );
2222  }
2223
2224  public void forAllCategory (
2225    short operator,
2226    String  [] filterValues
2227  ) {
2228    java.util.List   arrayAsList = new java.util.ArrayList  ();
2229    for(int i = 0; i < filterValues.length; i++) {
2230      arrayAsList.add(
2231        filterValues[i]
2232      );
2233    }
2234    forAllCategory (
2235      operator,
2236      arrayAsList
2237    );
2238  }
2239
2240  public void thereExistsCategory (
2241    short operator,
2242    String  [] filterValues
2243  ) {
2244    java.util.List   arrayAsList = new java.util.ArrayList  ();
2245    for(int i = 0; i < filterValues.length; i++) {
2246      arrayAsList.add(
2247        filterValues[i]
2248      );
2249    }
2250    thereExistsCategory (
2251      operator,
2252      arrayAsList
2253    );
2254  }
2255
2256  public void orderByCategory (
2257    short order
2258  ) {
2259    refAddValue(
2260      "org:opencrx:kernel:generic:CrxObject:category",
2261      order
2262    );
2263  }
2264      
2265// ----------------------------------------------------------------------------
2266// Filter/ImplAttributeIsNotStruct
2267// ----------------------------------------------------------------------------
2268  public void forAllDisabled (
2269    short operator,
2270    java.util.Collection   values
2271  ) {
2272    refAddValue(
2273      "org:opencrx:kernel:generic:CrxObject:disabled",
2274      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2275      operator,
2276      values
2277    );
2278  }
2279
2280  public void thereExistsDisabled (
2281    short operator,
2282    java.util.Collection   values
2283  ) {
2284    refAddValue(
2285      "org:opencrx:kernel:generic:CrxObject:disabled",
2286      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2287      operator,
2288      values
2289    );
2290  }
2291
2292  public void forAllDisabled (
2293    short operator,
2294    boolean[] filterValues
2295  ) {
2296    java.util.List   arrayAsList = new java.util.ArrayList  ();
2297    for(int i = 0; i < filterValues.length; i++) {
2298      arrayAsList.add(
2299        new Boolean  (filterValues[i])
2300      );
2301    }
2302    forAllDisabled (
2303      operator,
2304      arrayAsList
2305    );
2306  }
2307
2308  public void thereExistsDisabled (
2309    short operator,
2310    boolean[] filterValues
2311  ) {
2312    java.util.List   arrayAsList = new java.util.ArrayList  ();
2313    for(int i = 0; i < filterValues.length; i++) {
2314      arrayAsList.add(
2315        new Boolean  (filterValues[i])
2316      );
2317    }
2318    thereExistsDisabled (
2319      operator,
2320      arrayAsList
2321    );
2322  }
2323
2324  public void orderByDisabled (
2325    short order
2326  ) {
2327    refAddValue(
2328      "org:opencrx:kernel:generic:CrxObject:disabled",
2329      order
2330    );
2331  }
2332      
2333// ----------------------------------------------------------------------------
2334// Filter/ImplAttributeIsNotStruct
2335// ----------------------------------------------------------------------------
2336  public void forAllDisabledReason (
2337    short operator,
2338    java.util.Collection   values
2339  ) {
2340    refAddValue(
2341      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2342      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2343      operator,
2344      values
2345    );
2346  }
2347
2348  public void thereExistsDisabledReason (
2349    short operator,
2350    java.util.Collection   values
2351  ) {
2352    refAddValue(
2353      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2354      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2355      operator,
2356      values
2357    );
2358  }
2359
2360  public void forAllDisabledReason (
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    forAllDisabledReason (
2371      operator,
2372      arrayAsList
2373    );
2374  }
2375
2376  public void thereExistsDisabledReason (
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    thereExistsDisabledReason (
2387      operator,
2388      arrayAsList
2389    );
2390  }
2391
2392  public void orderByDisabledReason (
2393    short order
2394  ) {
2395    refAddValue(
2396      "org:opencrx:kernel:generic:CrxObject:disabledReason",
2397      order
2398    );
2399  }
2400      
2401// ----------------------------------------------------------------------------
2402// Filter/ImplAttributeIsNotStruct
2403// ----------------------------------------------------------------------------
2404  public void forAllExternalLink (
2405    short operator,
2406    java.util.Collection   values
2407  ) {
2408    refAddValue(
2409      "org:opencrx:kernel:generic:CrxObject:externalLink",
2410      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2411      operator,
2412      values
2413    );
2414  }
2415
2416  public void thereExistsExternalLink (
2417    short operator,
2418    java.util.Collection   values
2419  ) {
2420    refAddValue(
2421      "org:opencrx:kernel:generic:CrxObject:externalLink",
2422      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2423      operator,
2424      values
2425    );
2426  }
2427
2428  public void forAllExternalLink (
2429    short operator,
2430    String  [] filterValues
2431  ) {
2432    java.util.List   arrayAsList = new java.util.ArrayList  ();
2433    for(int i = 0; i < filterValues.length; i++) {
2434      arrayAsList.add(
2435        filterValues[i]
2436      );
2437    }
2438    forAllExternalLink (
2439      operator,
2440      arrayAsList
2441    );
2442  }
2443
2444  public void thereExistsExternalLink (
2445    short operator,
2446    String  [] filterValues
2447  ) {
2448    java.util.List   arrayAsList = new java.util.ArrayList  ();
2449    for(int i = 0; i < filterValues.length; i++) {
2450      arrayAsList.add(
2451        filterValues[i]
2452      );
2453    }
2454    thereExistsExternalLink (
2455      operator,
2456      arrayAsList
2457    );
2458  }
2459
2460  public void orderByExternalLink (
2461    short order
2462  ) {
2463    refAddValue(
2464      "org:opencrx:kernel:generic:CrxObject:externalLink",
2465      order
2466    );
2467  }
2468      
2469// ----------------------------------------------------------------------------
2470// Filter/ImplAttributeIsNotStruct
2471// ----------------------------------------------------------------------------
2472  public void forAllUserBoolean0 (
2473    short operator,
2474    java.util.Collection   values
2475  ) {
2476    refAddValue(
2477      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2478      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2479      operator,
2480      values
2481    );
2482  }
2483
2484  public void thereExistsUserBoolean0 (
2485    short operator,
2486    java.util.Collection   values
2487  ) {
2488    refAddValue(
2489      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2490      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2491      operator,
2492      values
2493    );
2494  }
2495
2496  public void forAllUserBoolean0 (
2497    short operator,
2498    boolean[] filterValues
2499  ) {
2500    java.util.List   arrayAsList = new java.util.ArrayList  ();
2501    for(int i = 0; i < filterValues.length; i++) {
2502      arrayAsList.add(
2503        new Boolean  (filterValues[i])
2504      );
2505    }
2506    forAllUserBoolean0 (
2507      operator,
2508      arrayAsList
2509    );
2510  }
2511
2512  public void thereExistsUserBoolean0 (
2513    short operator,
2514    boolean[] filterValues
2515  ) {
2516    java.util.List   arrayAsList = new java.util.ArrayList  ();
2517    for(int i = 0; i < filterValues.length; i++) {
2518      arrayAsList.add(
2519        new Boolean  (filterValues[i])
2520      );
2521    }
2522    thereExistsUserBoolean0 (
2523      operator,
2524      arrayAsList
2525    );
2526  }
2527
2528  public void orderByUserBoolean0 (
2529    short order
2530  ) {
2531    refAddValue(
2532      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
2533      order
2534    );
2535  }
2536      
2537// ----------------------------------------------------------------------------
2538// Filter/ImplAttributeIsNotStruct
2539// ----------------------------------------------------------------------------
2540  public void forAllUserBoolean1 (
2541    short operator,
2542    java.util.Collection   values
2543  ) {
2544    refAddValue(
2545      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2546      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2547      operator,
2548      values
2549    );
2550  }
2551
2552  public void thereExistsUserBoolean1 (
2553    short operator,
2554    java.util.Collection   values
2555  ) {
2556    refAddValue(
2557      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2558      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2559      operator,
2560      values
2561    );
2562  }
2563
2564  public void forAllUserBoolean1 (
2565    short operator,
2566    boolean[] filterValues
2567  ) {
2568    java.util.List   arrayAsList = new java.util.ArrayList  ();
2569    for(int i = 0; i < filterValues.length; i++) {
2570      arrayAsList.add(
2571        new Boolean  (filterValues[i])
2572      );
2573    }
2574    forAllUserBoolean1 (
2575      operator,
2576      arrayAsList
2577    );
2578  }
2579
2580  public void thereExistsUserBoolean1 (
2581    short operator,
2582    boolean[] filterValues
2583  ) {
2584    java.util.List   arrayAsList = new java.util.ArrayList  ();
2585    for(int i = 0; i < filterValues.length; i++) {
2586      arrayAsList.add(
2587        new Boolean  (filterValues[i])
2588      );
2589    }
2590    thereExistsUserBoolean1 (
2591      operator,
2592      arrayAsList
2593    );
2594  }
2595
2596  public void orderByUserBoolean1 (
2597    short order
2598  ) {
2599    refAddValue(
2600      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
2601      order
2602    );
2603  }
2604      
2605// ----------------------------------------------------------------------------
2606// Filter/ImplAttributeIsNotStruct
2607// ----------------------------------------------------------------------------
2608  public void forAllUserBoolean2 (
2609    short operator,
2610    java.util.Collection   values
2611  ) {
2612    refAddValue(
2613      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2614      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2615      operator,
2616      values
2617    );
2618  }
2619
2620  public void thereExistsUserBoolean2 (
2621    short operator,
2622    java.util.Collection   values
2623  ) {
2624    refAddValue(
2625      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2626      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2627      operator,
2628      values
2629    );
2630  }
2631
2632  public void forAllUserBoolean2 (
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    forAllUserBoolean2 (
2643      operator,
2644      arrayAsList
2645    );
2646  }
2647
2648  public void thereExistsUserBoolean2 (
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    thereExistsUserBoolean2 (
2659      operator,
2660      arrayAsList
2661    );
2662  }
2663
2664  public void orderByUserBoolean2 (
2665    short order
2666  ) {
2667    refAddValue(
2668      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2669      order
2670    );
2671  }
2672      
2673// ----------------------------------------------------------------------------
2674// Filter/ImplAttributeIsNotStruct
2675// ----------------------------------------------------------------------------
2676  public void forAllUserBoolean3 (
2677    short operator,
2678    java.util.Collection   values
2679  ) {
2680    refAddValue(
2681      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2682      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2683      operator,
2684      values
2685    );
2686  }
2687
2688  public void thereExistsUserBoolean3 (
2689    short operator,
2690    java.util.Collection   values
2691  ) {
2692    refAddValue(
2693      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2694      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2695      operator,
2696      values
2697    );
2698  }
2699
2700  public void forAllUserBoolean3 (
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    forAllUserBoolean3 (
2711      operator,
2712      arrayAsList
2713    );
2714  }
2715
2716  public void thereExistsUserBoolean3 (
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    thereExistsUserBoolean3 (
2727      operator,
2728      arrayAsList
2729    );
2730  }
2731
2732  public void orderByUserBoolean3 (
2733    short order
2734  ) {
2735    refAddValue(
2736      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2737      order
2738    );
2739  }
2740      
2741// ----------------------------------------------------------------------------
2742// Filter/ImplAttributeIsNotStruct
2743// ----------------------------------------------------------------------------
2744  public void forAllUserBoolean4 (
2745    short operator,
2746    java.util.Collection   values
2747  ) {
2748    refAddValue(
2749      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2750      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2751      operator,
2752      values
2753    );
2754  }
2755
2756  public void thereExistsUserBoolean4 (
2757    short operator,
2758    java.util.Collection   values
2759  ) {
2760    refAddValue(
2761      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2762      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2763      operator,
2764      values
2765    );
2766  }
2767
2768  public void forAllUserBoolean4 (
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    forAllUserBoolean4 (
2779      operator,
2780      arrayAsList
2781    );
2782  }
2783
2784  public void thereExistsUserBoolean4 (
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    thereExistsUserBoolean4 (
2795      operator,
2796      arrayAsList
2797    );
2798  }
2799
2800  public void orderByUserBoolean4 (
2801    short order
2802  ) {
2803    refAddValue(
2804      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2805      order
2806    );
2807  }
2808      
2809// ----------------------------------------------------------------------------
2810// Filter/ImplAttributeIsNotStruct
2811// ----------------------------------------------------------------------------
2812  public void forAllUserCode0 (
2813    short operator,
2814    java.util.Collection   values
2815  ) {
2816    refAddValue(
2817      "org:opencrx:kernel:generic:CrxObject:userCode0",
2818      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2819      operator,
2820      values
2821    );
2822  }
2823
2824  public void thereExistsUserCode0 (
2825    short operator,
2826    java.util.Collection   values
2827  ) {
2828    refAddValue(
2829      "org:opencrx:kernel:generic:CrxObject:userCode0",
2830      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2831      operator,
2832      values
2833    );
2834  }
2835
2836  public void forAllUserCode0 (
2837    short operator,
2838    short[] 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 Short  (filterValues[i])
2844      );
2845    }
2846    forAllUserCode0 (
2847      operator,
2848      arrayAsList
2849    );
2850  }
2851
2852  public void thereExistsUserCode0 (
2853    short operator,
2854    short[] 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 Short  (filterValues[i])
2860      );
2861    }
2862    thereExistsUserCode0 (
2863      operator,
2864      arrayAsList
2865    );
2866  }
2867
2868  public void orderByUserCode0 (
2869    short order
2870  ) {
2871    refAddValue(
2872      "org:opencrx:kernel:generic:CrxObject:userCode0",
2873      order
2874    );
2875  }
2876      
2877// ----------------------------------------------------------------------------
2878// Filter/ImplAttributeIsNotStruct
2879// ----------------------------------------------------------------------------
2880  public void forAllUserCode1 (
2881    short operator,
2882    java.util.Collection   values
2883  ) {
2884    refAddValue(
2885      "org:opencrx:kernel:generic:CrxObject:userCode1",
2886      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2887      operator,
2888      values
2889    );
2890  }
2891
2892  public void thereExistsUserCode1 (
2893    short operator,
2894    java.util.Collection   values
2895  ) {
2896    refAddValue(
2897      "org:opencrx:kernel:generic:CrxObject:userCode1",
2898      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2899      operator,
2900      values
2901    );
2902  }
2903
2904  public void forAllUserCode1 (
2905    short operator,
2906    short[] 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 Short  (filterValues[i])
2912      );
2913    }
2914    forAllUserCode1 (
2915      operator,
2916      arrayAsList
2917    );
2918  }
2919
2920  public void thereExistsUserCode1 (
2921    short operator,
2922    short[] 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 Short  (filterValues[i])
2928      );
2929    }
2930    thereExistsUserCode1 (
2931      operator,
2932      arrayAsList
2933    );
2934  }
2935
2936  public void orderByUserCode1 (
2937    short order
2938  ) {
2939    refAddValue(
2940      "org:opencrx:kernel:generic:CrxObject:userCode1",
2941      order
2942    );
2943  }
2944      
2945// ----------------------------------------------------------------------------
2946// Filter/ImplAttributeIsNotStruct
2947// ----------------------------------------------------------------------------
2948  public void forAllUserCode2 (
2949    short operator,
2950    java.util.Collection   values
2951  ) {
2952    refAddValue(
2953      "org:opencrx:kernel:generic:CrxObject:userCode2",
2954      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2955      operator,
2956      values
2957    );
2958  }
2959
2960  public void thereExistsUserCode2 (
2961    short operator,
2962    java.util.Collection   values
2963  ) {
2964    refAddValue(
2965      "org:opencrx:kernel:generic:CrxObject:userCode2",
2966      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2967      operator,
2968      values
2969    );
2970  }
2971
2972  public void forAllUserCode2 (
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    forAllUserCode2 (
2983      operator,
2984      arrayAsList
2985    );
2986  }
2987
2988  public void thereExistsUserCode2 (
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    thereExistsUserCode2 (
2999      operator,
3000      arrayAsList
3001    );
3002  }
3003
3004  public void orderByUserCode2 (
3005    short order
3006  ) {
3007    refAddValue(
3008      "org:opencrx:kernel:generic:CrxObject:userCode2",
3009      order
3010    );
3011  }
3012      
3013// ----------------------------------------------------------------------------
3014// Filter/ImplAttributeIsNotStruct
3015// ----------------------------------------------------------------------------
3016  public void forAllUserCode3 (
3017    short operator,
3018    java.util.Collection   values
3019  ) {
3020    refAddValue(
3021      "org:opencrx:kernel:generic:CrxObject:userCode3",
3022      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3023      operator,
3024      values
3025    );
3026  }
3027
3028  public void thereExistsUserCode3 (
3029    short operator,
3030    java.util.Collection   values
3031  ) {
3032    refAddValue(
3033      "org:opencrx:kernel:generic:CrxObject:userCode3",
3034      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3035      operator,
3036      values
3037    );
3038  }
3039
3040  public void forAllUserCode3 (
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    forAllUserCode3 (
3051      operator,
3052      arrayAsList
3053    );
3054  }
3055
3056  public void thereExistsUserCode3 (
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    thereExistsUserCode3 (
3067      operator,
3068      arrayAsList
3069    );
3070  }
3071
3072  public void orderByUserCode3 (
3073    short order
3074  ) {
3075    refAddValue(
3076      "org:opencrx:kernel:generic:CrxObject:userCode3",
3077      order
3078    );
3079  }
3080      
3081// ----------------------------------------------------------------------------
3082// Filter/ImplAttributeIsNotStruct
3083// ----------------------------------------------------------------------------
3084  public void forAllUserCode4 (
3085    short operator,
3086    java.util.Collection   values
3087  ) {
3088    refAddValue(
3089      "org:opencrx:kernel:generic:CrxObject:userCode4",
3090      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3091      operator,
3092      values
3093    );
3094  }
3095
3096  public void thereExistsUserCode4 (
3097    short operator,
3098    java.util.Collection   values
3099  ) {
3100    refAddValue(
3101      "org:opencrx:kernel:generic:CrxObject:userCode4",
3102      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3103      operator,
3104      values
3105    );
3106  }
3107
3108  public void forAllUserCode4 (
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    forAllUserCode4 (
3119      operator,
3120      arrayAsList
3121    );
3122  }
3123
3124  public void thereExistsUserCode4 (
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    thereExistsUserCode4 (
3135      operator,
3136      arrayAsList
3137    );
3138  }
3139
3140  public void orderByUserCode4 (
3141    short order
3142  ) {
3143    refAddValue(
3144      "org:opencrx:kernel:generic:CrxObject:userCode4",
3145      order
3146    );
3147  }
3148      
3149// ----------------------------------------------------------------------------
3150// Filter/ImplAttributeIsNotStruct
3151// ----------------------------------------------------------------------------
3152  public void forAllUserDate0 (
3153    short operator,
3154    java.util.Collection   values
3155  ) {
3156    refAddValue(
3157      "org:opencrx:kernel:generic:CrxObject:userDate0",
3158      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3159      operator,
3160      values
3161    );
3162  }
3163
3164  public void thereExistsUserDate0 (
3165    short operator,
3166    java.util.Collection   values
3167  ) {
3168    refAddValue(
3169      "org:opencrx:kernel:generic:CrxObject:userDate0",
3170      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3171      operator,
3172      values
3173    );
3174  }
3175
3176  public void forAllUserDate0 (
3177    short operator,
3178    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3179  ) {
3180    java.util.List   arrayAsList = new java.util.ArrayList  ();
3181    for(int i = 0; i < filterValues.length; i++) {
3182      arrayAsList.add(
3183        filterValues[i]
3184      );
3185    }
3186    forAllUserDate0 (
3187      operator,
3188      arrayAsList
3189    );
3190  }
3191
3192  public void thereExistsUserDate0 (
3193    short operator,
3194    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3195  ) {
3196    java.util.List   arrayAsList = new java.util.ArrayList  ();
3197    for(int i = 0; i < filterValues.length; i++) {
3198      arrayAsList.add(
3199        filterValues[i]
3200      );
3201    }
3202    thereExistsUserDate0 (
3203      operator,
3204      arrayAsList
3205    );
3206  }
3207
3208  public void orderByUserDate0 (
3209    short order
3210  ) {
3211    refAddValue(
3212      "org:opencrx:kernel:generic:CrxObject:userDate0",
3213      order
3214    );
3215  }
3216      
3217// ----------------------------------------------------------------------------
3218// Filter/ImplAttributeIsNotStruct
3219// ----------------------------------------------------------------------------
3220  public void forAllUserDate1 (
3221    short operator,
3222    java.util.Collection   values
3223  ) {
3224    refAddValue(
3225      "org:opencrx:kernel:generic:CrxObject:userDate1",
3226      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3227      operator,
3228      values
3229    );
3230  }
3231
3232  public void thereExistsUserDate1 (
3233    short operator,
3234    java.util.Collection   values
3235  ) {
3236    refAddValue(
3237      "org:opencrx:kernel:generic:CrxObject:userDate1",
3238      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3239      operator,
3240      values
3241    );
3242  }
3243
3244  public void forAllUserDate1 (
3245    short operator,
3246    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3247  ) {
3248    java.util.List   arrayAsList = new java.util.ArrayList  ();
3249    for(int i = 0; i < filterValues.length; i++) {
3250      arrayAsList.add(
3251        filterValues[i]
3252      );
3253    }
3254    forAllUserDate1 (
3255      operator,
3256      arrayAsList
3257    );
3258  }
3259
3260  public void thereExistsUserDate1 (
3261    short operator,
3262    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
3263  ) {
3264    java.util.List   arrayAsList = new java.util.ArrayList  ();
3265    for(int i = 0; i < filterValues.length; i++) {
3266      arrayAsList.add(
3267        filterValues[i]
3268      );
3269    }
3270    thereExistsUserDate1 (
3271      operator,
3272      arrayAsList
3273    );
3274  }
3275
3276  public void orderByUserDate1 (
3277    short order
3278  ) {
3279    refAddValue(
3280      "org:opencrx:kernel:generic:CrxObject:userDate1",
3281      order
3282    );
3283  }
3284      
3285// ----------------------------------------------------------------------------
3286// Filter/ImplAttributeIsNotStruct
3287// ----------------------------------------------------------------------------
3288  public void forAllUserDate2 (
3289    short operator,
3290    java.util.Collection   values
3291  ) {
3292    refAddValue(
3293      "org:opencrx:kernel:generic:CrxObject:userDate2",
3294      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3295      operator,
3296      values
3297    );
3298  }
3299
3300  public void thereExistsUserDate2 (
3301    short operator,
3302    java.util.Collection   values
3303  ) {
3304    refAddValue(
3305      "org:opencrx:kernel:generic:CrxObject:userDate2",
3306      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3307      operator,
3308      values
3309    );
3310  }
3311
3312  public void forAllUserDate2 (
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    forAllUserDate2 (
3323      operator,
3324      arrayAsList
3325    );
3326  }
3327
3328  public void thereExistsUserDate2 (
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    thereExistsUserDate2 (
3339      operator,
3340      arrayAsList
3341    );
3342  }
3343
3344  public void orderByUserDate2 (
3345    short order
3346  ) {
3347    refAddValue(
3348      "org:opencrx:kernel:generic:CrxObject:userDate2",
3349      order
3350    );
3351  }
3352      
3353// ----------------------------------------------------------------------------
3354// Filter/ImplAttributeIsNotStruct
3355// ----------------------------------------------------------------------------
3356  public void forAllUserDate3 (
3357    short operator,
3358    java.util.Collection   values
3359  ) {
3360    refAddValue(
3361      "org:opencrx:kernel:generic:CrxObject:userDate3",
3362      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3363      operator,
3364      values
3365    );
3366  }
3367
3368  public void thereExistsUserDate3 (
3369    short operator,
3370    java.util.Collection   values
3371  ) {
3372    refAddValue(
3373      "org:opencrx:kernel:generic:CrxObject:userDate3",
3374      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3375      operator,
3376      values
3377    );
3378  }
3379
3380  public void forAllUserDate3 (
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    forAllUserDate3 (
3391      operator,
3392      arrayAsList
3393    );
3394  }
3395
3396  public void thereExistsUserDate3 (
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    thereExistsUserDate3 (
3407      operator,
3408      arrayAsList
3409    );
3410  }
3411
3412  public void orderByUserDate3 (
3413    short order
3414  ) {
3415    refAddValue(
3416      "org:opencrx:kernel:generic:CrxObject:userDate3",
3417      order
3418    );
3419  }
3420      
3421// ----------------------------------------------------------------------------
3422// Filter/ImplAttributeIsNotStruct
3423// ----------------------------------------------------------------------------
3424  public void forAllUserDate4 (
3425    short operator,
3426    java.util.Collection   values
3427  ) {
3428    refAddValue(
3429      "org:opencrx:kernel:generic:CrxObject:userDate4",
3430      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3431      operator,
3432      values
3433    );
3434  }
3435
3436  public void thereExistsUserDate4 (
3437    short operator,
3438    java.util.Collection   values
3439  ) {
3440    refAddValue(
3441      "org:opencrx:kernel:generic:CrxObject:userDate4",
3442      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3443      operator,
3444      values
3445    );
3446  }
3447
3448  public void forAllUserDate4 (
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    forAllUserDate4 (
3459      operator,
3460      arrayAsList
3461    );
3462  }
3463
3464  public void thereExistsUserDate4 (
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    thereExistsUserDate4 (
3475      operator,
3476      arrayAsList
3477    );
3478  }
3479
3480  public void orderByUserDate4 (
3481    short order
3482  ) {
3483    refAddValue(
3484      "org:opencrx:kernel:generic:CrxObject:userDate4",
3485      order
3486    );
3487  }
3488      
3489// ----------------------------------------------------------------------------
3490// Filter/ImplAttributeIsNotStruct
3491// ----------------------------------------------------------------------------
3492  public void forAllUserDateTime0 (
3493    short operator,
3494    java.util.Collection   values
3495  ) {
3496    refAddValue(
3497      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3498      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3499      operator,
3500      values
3501    );
3502  }
3503
3504  public void thereExistsUserDateTime0 (
3505    short operator,
3506    java.util.Collection   values
3507  ) {
3508    refAddValue(
3509      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3510      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3511      operator,
3512      values
3513    );
3514  }
3515
3516  public void forAllUserDateTime0 (
3517    short operator,
3518    java.util.Date  [] 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    forAllUserDateTime0 (
3527      operator,
3528      arrayAsList
3529    );
3530  }
3531
3532  public void thereExistsUserDateTime0 (
3533    short operator,
3534    java.util.Date  [] 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    thereExistsUserDateTime0 (
3543      operator,
3544      arrayAsList
3545    );
3546  }
3547
3548  public void orderByUserDateTime0 (
3549    short order
3550  ) {
3551    refAddValue(
3552      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
3553      order
3554    );
3555  }
3556      
3557// ----------------------------------------------------------------------------
3558// Filter/ImplAttributeIsNotStruct
3559// ----------------------------------------------------------------------------
3560  public void forAllUserDateTime1 (
3561    short operator,
3562    java.util.Collection   values
3563  ) {
3564    refAddValue(
3565      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3566      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3567      operator,
3568      values
3569    );
3570  }
3571
3572  public void thereExistsUserDateTime1 (
3573    short operator,
3574    java.util.Collection   values
3575  ) {
3576    refAddValue(
3577      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3578      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3579      operator,
3580      values
3581    );
3582  }
3583
3584  public void forAllUserDateTime1 (
3585    short operator,
3586    java.util.Date  [] 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    forAllUserDateTime1 (
3595      operator,
3596      arrayAsList
3597    );
3598  }
3599
3600  public void thereExistsUserDateTime1 (
3601    short operator,
3602    java.util.Date  [] 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    thereExistsUserDateTime1 (
3611      operator,
3612      arrayAsList
3613    );
3614  }
3615
3616  public void orderByUserDateTime1 (
3617    short order
3618  ) {
3619    refAddValue(
3620      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
3621      order
3622    );
3623  }
3624      
3625// ----------------------------------------------------------------------------
3626// Filter/ImplAttributeIsNotStruct
3627// ----------------------------------------------------------------------------
3628  public void forAllUserDateTime2 (
3629    short operator,
3630    java.util.Collection   values
3631  ) {
3632    refAddValue(
3633      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3634      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3635      operator,
3636      values
3637    );
3638  }
3639
3640  public void thereExistsUserDateTime2 (
3641    short operator,
3642    java.util.Collection   values
3643  ) {
3644    refAddValue(
3645      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3646      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3647      operator,
3648      values
3649    );
3650  }
3651
3652  public void forAllUserDateTime2 (
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    forAllUserDateTime2 (
3663      operator,
3664      arrayAsList
3665    );
3666  }
3667
3668  public void thereExistsUserDateTime2 (
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    thereExistsUserDateTime2 (
3679      operator,
3680      arrayAsList
3681    );
3682  }
3683
3684  public void orderByUserDateTime2 (
3685    short order
3686  ) {
3687    refAddValue(
3688      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3689      order
3690    );
3691  }
3692      
3693// ----------------------------------------------------------------------------
3694// Filter/ImplAttributeIsNotStruct
3695// ----------------------------------------------------------------------------
3696  public void forAllUserDateTime3 (
3697    short operator,
3698    java.util.Collection   values
3699  ) {
3700    refAddValue(
3701      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3702      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3703      operator,
3704      values
3705    );
3706  }
3707
3708  public void thereExistsUserDateTime3 (
3709    short operator,
3710    java.util.Collection   values
3711  ) {
3712    refAddValue(
3713      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3714      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3715      operator,
3716      values
3717    );
3718  }
3719
3720  public void forAllUserDateTime3 (
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    forAllUserDateTime3 (
3731      operator,
3732      arrayAsList
3733    );
3734  }
3735
3736  public void thereExistsUserDateTime3 (
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    thereExistsUserDateTime3 (
3747      operator,
3748      arrayAsList
3749    );
3750  }
3751
3752  public void orderByUserDateTime3 (
3753    short order
3754  ) {
3755    refAddValue(
3756      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3757      order
3758    );
3759  }
3760      
3761// ----------------------------------------------------------------------------
3762// Filter/ImplAttributeIsNotStruct
3763// ----------------------------------------------------------------------------
3764  public void forAllUserDateTime4 (
3765    short operator,
3766    java.util.Collection   values
3767  ) {
3768    refAddValue(
3769      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3770      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3771      operator,
3772      values
3773    );
3774  }
3775
3776  public void thereExistsUserDateTime4 (
3777    short operator,
3778    java.util.Collection   values
3779  ) {
3780    refAddValue(
3781      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3782      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3783      operator,
3784      values
3785    );
3786  }
3787
3788  public void forAllUserDateTime4 (
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    forAllUserDateTime4 (
3799      operator,
3800      arrayAsList
3801    );
3802  }
3803
3804  public void thereExistsUserDateTime4 (
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    thereExistsUserDateTime4 (
3815      operator,
3816      arrayAsList
3817    );
3818  }
3819
3820  public void orderByUserDateTime4 (
3821    short order
3822  ) {
3823    refAddValue(
3824      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3825      order
3826    );
3827  }
3828      
3829// ----------------------------------------------------------------------------
3830// Filter/ImplAttributeIsNotStruct
3831// ----------------------------------------------------------------------------
3832  public void forAllUserNumber0 (
3833    short operator,
3834    java.util.Collection   values
3835  ) {
3836    refAddValue(
3837      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3838      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3839      operator,
3840      values
3841    );
3842  }
3843
3844  public void thereExistsUserNumber0 (
3845    short operator,
3846    java.util.Collection   values
3847  ) {
3848    refAddValue(
3849      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3850      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3851      operator,
3852      values
3853    );
3854  }
3855
3856  public void forAllUserNumber0 (
3857    short operator,
3858    java.math.BigDecimal  [] 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    forAllUserNumber0 (
3867      operator,
3868      arrayAsList
3869    );
3870  }
3871
3872  public void thereExistsUserNumber0 (
3873    short operator,
3874    java.math.BigDecimal  [] 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    thereExistsUserNumber0 (
3883      operator,
3884      arrayAsList
3885    );
3886  }
3887
3888  public void orderByUserNumber0 (
3889    short order
3890  ) {
3891    refAddValue(
3892      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3893      order
3894    );
3895  }
3896      
3897// ----------------------------------------------------------------------------
3898// Filter/ImplAttributeIsNotStruct
3899// ----------------------------------------------------------------------------
3900  public void forAllUserNumber1 (
3901    short operator,
3902    java.util.Collection   values
3903  ) {
3904    refAddValue(
3905      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3906      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3907      operator,
3908      values
3909    );
3910  }
3911
3912  public void thereExistsUserNumber1 (
3913    short operator,
3914    java.util.Collection   values
3915  ) {
3916    refAddValue(
3917      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3918      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3919      operator,
3920      values
3921    );
3922  }
3923
3924  public void forAllUserNumber1 (
3925    short operator,
3926    java.math.BigDecimal  [] 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    forAllUserNumber1 (
3935      operator,
3936      arrayAsList
3937    );
3938  }
3939
3940  public void thereExistsUserNumber1 (
3941    short operator,
3942    java.math.BigDecimal  [] 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    thereExistsUserNumber1 (
3951      operator,
3952      arrayAsList
3953    );
3954  }
3955
3956  public void orderByUserNumber1 (
3957    short order
3958  ) {
3959    refAddValue(
3960      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3961      order
3962    );
3963  }
3964      
3965// ----------------------------------------------------------------------------
3966// Filter/ImplAttributeIsNotStruct
3967// ----------------------------------------------------------------------------
3968  public void forAllUserNumber2 (
3969    short operator,
3970    java.util.Collection   values
3971  ) {
3972    refAddValue(
3973      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3974      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3975      operator,
3976      values
3977    );
3978  }
3979
3980  public void thereExistsUserNumber2 (
3981    short operator,
3982    java.util.Collection   values
3983  ) {
3984    refAddValue(
3985      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3986      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3987      operator,
3988      values
3989    );
3990  }
3991
3992  public void forAllUserNumber2 (
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    forAllUserNumber2 (
4003      operator,
4004      arrayAsList
4005    );
4006  }
4007
4008  public void thereExistsUserNumber2 (
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    thereExistsUserNumber2 (
4019      operator,
4020      arrayAsList
4021    );
4022  }
4023
4024  public void orderByUserNumber2 (
4025    short order
4026  ) {
4027    refAddValue(
4028      "org:opencrx:kernel:generic:CrxObject:userNumber2",
4029      order
4030    );
4031  }
4032      
4033// ----------------------------------------------------------------------------
4034// Filter/ImplAttributeIsNotStruct
4035// ----------------------------------------------------------------------------
4036  public void forAllUserNumber3 (
4037    short operator,
4038    java.util.Collection   values
4039  ) {
4040    refAddValue(
4041      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4042      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4043      operator,
4044      values
4045    );
4046  }
4047
4048  public void thereExistsUserNumber3 (
4049    short operator,
4050    java.util.Collection   values
4051  ) {
4052    refAddValue(
4053      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4054      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4055      operator,
4056      values
4057    );
4058  }
4059
4060  public void forAllUserNumber3 (
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    forAllUserNumber3 (
4071      operator,
4072      arrayAsList
4073    );
4074  }
4075
4076  public void thereExistsUserNumber3 (
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    thereExistsUserNumber3 (
4087      operator,
4088      arrayAsList
4089    );
4090  }
4091
4092  public void orderByUserNumber3 (
4093    short order
4094  ) {
4095    refAddValue(
4096      "org:opencrx:kernel:generic:CrxObject:userNumber3",
4097      order
4098    );
4099  }
4100      
4101// ----------------------------------------------------------------------------
4102// Filter/ImplAttributeIsNotStruct
4103// ----------------------------------------------------------------------------
4104  public void forAllUserNumber4 (
4105    short operator,
4106    java.util.Collection   values
4107  ) {
4108    refAddValue(
4109      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4110      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4111      operator,
4112      values
4113    );
4114  }
4115
4116  public void thereExistsUserNumber4 (
4117    short operator,
4118    java.util.Collection   values
4119  ) {
4120    refAddValue(
4121      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4122      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4123      operator,
4124      values
4125    );
4126  }
4127
4128  public void forAllUserNumber4 (
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    forAllUserNumber4 (
4139      operator,
4140      arrayAsList
4141    );
4142  }
4143
4144  public void thereExistsUserNumber4 (
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    thereExistsUserNumber4 (
4155      operator,
4156      arrayAsList
4157    );
4158  }
4159
4160  public void orderByUserNumber4 (
4161    short order
4162  ) {
4163    refAddValue(
4164      "org:opencrx:kernel:generic:CrxObject:userNumber4",
4165      order
4166    );
4167  }
4168      
4169// ----------------------------------------------------------------------------
4170// Filter/ImplAttributeIsNotStruct
4171// ----------------------------------------------------------------------------
4172  public void forAllUserString0 (
4173    short operator,
4174    java.util.Collection   values
4175  ) {
4176    refAddValue(
4177      "org:opencrx:kernel:generic:CrxObject:userString0",
4178      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4179      operator,
4180      values
4181    );
4182  }
4183
4184  public void thereExistsUserString0 (
4185    short operator,
4186    java.util.Collection   values
4187  ) {
4188    refAddValue(
4189      "org:opencrx:kernel:generic:CrxObject:userString0",
4190      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4191      operator,
4192      values
4193    );
4194  }
4195
4196  public void forAllUserString0 (
4197    short operator,
4198    String  [] 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    forAllUserString0 (
4207      operator,
4208      arrayAsList
4209    );
4210  }
4211
4212  public void thereExistsUserString0 (
4213    short operator,
4214    String  [] 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    thereExistsUserString0 (
4223      operator,
4224      arrayAsList
4225    );
4226  }
4227
4228  public void orderByUserString0 (
4229    short order
4230  ) {
4231    refAddValue(
4232      "org:opencrx:kernel:generic:CrxObject:userString0",
4233      order
4234    );
4235  }
4236      
4237// ----------------------------------------------------------------------------
4238// Filter/ImplAttributeIsNotStruct
4239// ----------------------------------------------------------------------------
4240  public void forAllUserString1 (
4241    short operator,
4242    java.util.Collection   values
4243  ) {
4244    refAddValue(
4245      "org:opencrx:kernel:generic:CrxObject:userString1",
4246      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4247      operator,
4248      values
4249    );
4250  }
4251
4252  public void thereExistsUserString1 (
4253    short operator,
4254    java.util.Collection   values
4255  ) {
4256    refAddValue(
4257      "org:opencrx:kernel:generic:CrxObject:userString1",
4258      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4259      operator,
4260      values
4261    );
4262  }
4263
4264  public void forAllUserString1 (
4265    short operator,
4266    String  [] 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    forAllUserString1 (
4275      operator,
4276      arrayAsList
4277    );
4278  }
4279
4280  public void thereExistsUserString1 (
4281    short operator,
4282    String  [] 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    thereExistsUserString1 (
4291      operator,
4292      arrayAsList
4293    );
4294  }
4295
4296  public void orderByUserString1 (
4297    short order
4298  ) {
4299    refAddValue(
4300      "org:opencrx:kernel:generic:CrxObject:userString1",
4301      order
4302    );
4303  }
4304      
4305// ----------------------------------------------------------------------------
4306// Filter/ImplAttributeIsNotStruct
4307// ----------------------------------------------------------------------------
4308  public void forAllUserString2 (
4309    short operator,
4310    java.util.Collection   values
4311  ) {
4312    refAddValue(
4313      "org:opencrx:kernel:generic:CrxObject:userString2",
4314      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4315      operator,
4316      values
4317    );
4318  }
4319
4320  public void thereExistsUserString2 (
4321    short operator,
4322    java.util.Collection   values
4323  ) {
4324    refAddValue(
4325      "org:opencrx:kernel:generic:CrxObject:userString2",
4326      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4327      operator,
4328      values
4329    );
4330  }
4331
4332  public void forAllUserString2 (
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    forAllUserString2 (
4343      operator,
4344      arrayAsList
4345    );
4346  }
4347
4348  public void thereExistsUserString2 (
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    thereExistsUserString2 (
4359      operator,
4360      arrayAsList
4361    );
4362  }
4363
4364  public void orderByUserString2 (
4365    short order
4366  ) {
4367    refAddValue(
4368      "org:opencrx:kernel:generic:CrxObject:userString2",
4369      order
4370    );
4371  }
4372      
4373// ----------------------------------------------------------------------------
4374// Filter/ImplAttributeIsNotStruct
4375// ----------------------------------------------------------------------------
4376  public void forAllUserString3 (
4377    short operator,
4378    java.util.Collection   values
4379  ) {
4380    refAddValue(
4381      "org:opencrx:kernel:generic:CrxObject:userString3",
4382      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4383      operator,
4384      values
4385    );
4386  }
4387
4388  public void thereExistsUserString3 (
4389    short operator,
4390    java.util.Collection   values
4391  ) {
4392    refAddValue(
4393      "org:opencrx:kernel:generic:CrxObject:userString3",
4394      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4395      operator,
4396      values
4397    );
4398  }
4399
4400  public void forAllUserString3 (
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    forAllUserString3 (
4411      operator,
4412      arrayAsList
4413    );
4414  }
4415
4416  public void thereExistsUserString3 (
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    thereExistsUserString3 (
4427      operator,
4428      arrayAsList
4429    );
4430  }
4431
4432  public void orderByUserString3 (
4433    short order
4434  ) {
4435    refAddValue(
4436      "org:opencrx:kernel:generic:CrxObject:userString3",
4437      order
4438    );
4439  }
4440      
4441// ----------------------------------------------------------------------------
4442// Filter/ImplAttributeIsNotStruct
4443// ----------------------------------------------------------------------------
4444  public void forAllUserString4 (
4445    short operator,
4446    java.util.Collection   values
4447  ) {
4448    refAddValue(
4449      "org:opencrx:kernel:generic:CrxObject:userString4",
4450      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4451      operator,
4452      values
4453    );
4454  }
4455
4456  public void thereExistsUserString4 (
4457    short operator,
4458    java.util.Collection   values
4459  ) {
4460    refAddValue(
4461      "org:opencrx:kernel:generic:CrxObject:userString4",
4462      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4463      operator,
4464      values
4465    );
4466  }
4467
4468  public void forAllUserString4 (
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    forAllUserString4 (
4479      operator,
4480      arrayAsList
4481    );
4482  }
4483
4484  public void thereExistsUserString4 (
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    thereExistsUserString4 (
4495      operator,
4496      arrayAsList
4497    );
4498  }
4499
4500  public void orderByUserString4 (
4501    short order
4502  ) {
4503    refAddValue(
4504      "org:opencrx:kernel:generic:CrxObject:userString4",
4505      order
4506    );
4507  }
4508      
4509// ----------------------------------------------------------------------------
4510// Filter/ImplAttributeIsNotStruct
4511// ----------------------------------------------------------------------------
4512  public void forAllCreatedAt (
4513    short operator,
4514    java.util.Collection   values
4515  ) {
4516    refAddValue(
4517      "org:openmdx:base:BasicObject:createdAt",
4518      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4519      operator,
4520      values
4521    );
4522  }
4523
4524  public void thereExistsCreatedAt (
4525    short operator,
4526    java.util.Collection   values
4527  ) {
4528    refAddValue(
4529      "org:openmdx:base:BasicObject:createdAt",
4530      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4531      operator,
4532      values
4533    );
4534  }
4535
4536  public void forAllCreatedAt (
4537    short operator,
4538    java.util.Date  [] 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    forAllCreatedAt (
4547      operator,
4548      arrayAsList
4549    );
4550  }
4551
4552  public void thereExistsCreatedAt (
4553    short operator,
4554    java.util.Date  [] 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    thereExistsCreatedAt (
4563      operator,
4564      arrayAsList
4565    );
4566  }
4567
4568  public void orderByCreatedAt (
4569    short order
4570  ) {
4571    refAddValue(
4572      "org:openmdx:base:BasicObject:createdAt",
4573      order
4574    );
4575  }
4576      
4577// ----------------------------------------------------------------------------
4578// Filter/ImplAttributeIsNotStruct
4579// ----------------------------------------------------------------------------
4580  public void forAllCreatedBy (
4581    short operator,
4582    java.util.Collection   values
4583  ) {
4584    refAddValue(
4585      "org:openmdx:base:BasicObject:createdBy",
4586      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4587      operator,
4588      values
4589    );
4590  }
4591
4592  public void thereExistsCreatedBy (
4593    short operator,
4594    java.util.Collection   values
4595  ) {
4596    refAddValue(
4597      "org:openmdx:base:BasicObject:createdBy",
4598      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4599      operator,
4600      values
4601    );
4602  }
4603
4604  public void forAllCreatedBy (
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    forAllCreatedBy (
4615      operator,
4616      arrayAsList
4617    );
4618  }
4619
4620  public void thereExistsCreatedBy (
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    thereExistsCreatedBy (
4631      operator,
4632      arrayAsList
4633    );
4634  }
4635
4636  public void orderByCreatedBy (
4637    short order
4638  ) {
4639    refAddValue(
4640      "org:openmdx:base:BasicObject:createdBy",
4641      order
4642    );
4643  }
4644      
4645// ----------------------------------------------------------------------------
4646// Filter/ImplAttributeIsNotStruct
4647// ----------------------------------------------------------------------------
4648  public void forAllModifiedAt (
4649    short operator,
4650    java.util.Collection   values
4651  ) {
4652    refAddValue(
4653      "org:openmdx:base:BasicObject:modifiedAt",
4654      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4655      operator,
4656      values
4657    );
4658  }
4659
4660  public void thereExistsModifiedAt (
4661    short operator,
4662    java.util.Collection   values
4663  ) {
4664    refAddValue(
4665      "org:openmdx:base:BasicObject:modifiedAt",
4666      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4667      operator,
4668      values
4669    );
4670  }
4671
4672  public void forAllModifiedAt (
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    forAllModifiedAt (
4683      operator,
4684      arrayAsList
4685    );
4686  }
4687
4688  public void thereExistsModifiedAt (
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    thereExistsModifiedAt (
4699      operator,
4700      arrayAsList
4701    );
4702  }
4703
4704  public void orderByModifiedAt (
4705    short order
4706  ) {
4707    refAddValue(
4708      "org:openmdx:base:BasicObject:modifiedAt",
4709      order
4710    );
4711  }
4712      
4713// ----------------------------------------------------------------------------
4714// Filter/ImplAttributeIsNotStruct
4715// ----------------------------------------------------------------------------
4716  public void forAllModifiedBy (
4717    short operator,
4718    java.util.Collection   values
4719  ) {
4720    refAddValue(
4721      "org:openmdx:base:BasicObject:modifiedBy",
4722      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4723      operator,
4724      values
4725    );
4726  }
4727
4728  public void thereExistsModifiedBy (
4729    short operator,
4730    java.util.Collection   values
4731  ) {
4732    refAddValue(
4733      "org:openmdx:base:BasicObject:modifiedBy",
4734      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4735      operator,
4736      values
4737    );
4738  }
4739
4740  public void forAllModifiedBy (
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    forAllModifiedBy (
4751      operator,
4752      arrayAsList
4753    );
4754  }
4755
4756  public void thereExistsModifiedBy (
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    thereExistsModifiedBy (
4767      operator,
4768      arrayAsList
4769    );
4770  }
4771
4772  public void orderByModifiedBy (
4773    short order
4774  ) {
4775    refAddValue(
4776      "org:openmdx:base:BasicObject:modifiedBy",
4777      order
4778    );
4779  }
4780      
4781// ----------------------------------------------------------------------------
4782// Filter/ImplReference
4783// ----------------------------------------------------------------------------
4784  public void forAllContext (
4785    short operator,
4786    org.openmdx.base.cci.Context[] filterValues
4787  ) {
4788    java.util.List   arrayAsList = new java.util.ArrayList  ();
4789    for(int i = 0; i < filterValues.length; i++) {
4790      arrayAsList.add(
4791        filterValues[i]
4792      );
4793    }
4794    forAllContext (
4795      operator,
4796      arrayAsList
4797    );
4798  }
4799
4800  public void thereExistsContext (
4801    short operator,
4802    org.openmdx.base.cci.Context[] filterValues
4803  ) {
4804    java.util.List   arrayAsList = new java.util.ArrayList  ();
4805    for(int i = 0; i < filterValues.length; i++) {
4806      arrayAsList.add(
4807        filterValues[i]
4808      );
4809    }
4810    thereExistsContext (
4811      operator,
4812      arrayAsList
4813    );
4814  }
4815
4816  public void forAllContext (
4817    short operator,
4818    java.util.Collection   values
4819  ) {
4820    refAddValue(
4821      "org:openmdx:base:ContextCapable:context",
4822      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4823      operator,
4824      values
4825    );
4826  }
4827
4828  public void thereExistsContext (
4829    short operator,
4830    java.util.Collection   values
4831  ) {
4832    refAddValue(
4833      "org:openmdx:base:ContextCapable:context",
4834      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4835      operator,
4836      values
4837    );
4838  }
4839      
4840// ----------------------------------------------------------------------------
4841// Filter/ImplAttributeIsNotStruct
4842// ----------------------------------------------------------------------------
4843  public void forAllIdentity (
4844    short operator,
4845    java.util.Collection   values
4846  ) {
4847    refAddValue(
4848      "org:openmdx:base:ExtentCapable:identity",
4849      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4850      operator,
4851      values
4852    );
4853  }
4854
4855  public void thereExistsIdentity (
4856    short operator,
4857    java.util.Collection   values
4858  ) {
4859    refAddValue(
4860      "org:openmdx:base:ExtentCapable:identity",
4861      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4862      operator,
4863      values
4864    );
4865  }
4866
4867  public void forAllIdentity (
4868    short operator,
4869    String  [] filterValues
4870  ) {
4871    java.util.List   arrayAsList = new java.util.ArrayList  ();
4872    for(int i = 0; i < filterValues.length; i++) {
4873      arrayAsList.add(
4874        filterValues[i]
4875      );
4876    }
4877    forAllIdentity (
4878      operator,
4879      arrayAsList
4880    );
4881  }
4882
4883  public void thereExistsIdentity (
4884    short operator,
4885    String  [] filterValues
4886  ) {
4887    java.util.List   arrayAsList = new java.util.ArrayList  ();
4888    for(int i = 0; i < filterValues.length; i++) {
4889      arrayAsList.add(
4890        filterValues[i]
4891      );
4892    }
4893    thereExistsIdentity (
4894      operator,
4895      arrayAsList
4896    );
4897  }
4898
4899  public void orderByIdentity (
4900    short order
4901  ) {
4902    refAddValue(
4903      "org:openmdx:base:ExtentCapable:identity",
4904      order
4905    );
4906  }
4907      
4908// ----------------------------------------------------------------------------
4909// Filter/ImplEnd
4910// ----------------------------------------------------------------------------
4911}        
4912
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags