IncidentFilterImpl


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