EMailFilterImpl


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