ContactFilterImpl


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:38:55 CEST 2006
9   //
10  // GENERATED - DO NOT CHANGE MANUALLY
11  //
12  //////////////////////////////////////////////////////////////////////////////
13  package org.opencrx.kernel.account1.cci;
14  
15  public class ContactFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements ContactFilter {
18  
19    public ContactFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:account1:Contact",
25        null,
26        null
27      );
28    }
29  
30    public ContactFilterImpl(
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:account1:Contact",
38        filterProperties,
39        attributeSpecifiers
40      );
41    }
42        
43  // ----------------------------------------------------------------------------
44  // Filter/ImplAttributeIsNotStruct
45  // ----------------------------------------------------------------------------
46    public void forAllAccountCategory (
47      short operator,
48      java.util.Collection   values
49    ) {
50      refAddValue(
51        "org:opencrx:kernel:account1:AbstractAccount:accountCategory",
52        org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53        operator,
54        values
55      );
56    }
57  
58    public void thereExistsAccountCategory (
59      short operator,
60      java.util.Collection   values
61    ) {
62      refAddValue(
63        "org:opencrx:kernel:account1:AbstractAccount:accountCategory",
64        org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65        operator,
66        values
67      );
68    }
69  
70    public void forAllAccountCategory (
71      short operator,
72      short[] filterValues
73    ) {
74      java.util.List   arrayAsList = new java.util.ArrayList  ();
75      for(int i = 0; i < filterValues.length; i++) {
76        arrayAsList.add(
77          new Short  (filterValues[i])
78        );
79      }
80      forAllAccountCategory (
81        operator,
82        arrayAsList
83      );
84    }
85  
86    public void thereExistsAccountCategory (
87      short operator,
88      short[] filterValues
89    ) {
90      java.util.List   arrayAsList = new java.util.ArrayList  ();
91      for(int i = 0; i < filterValues.length; i++) {
92        arrayAsList.add(
93          new Short  (filterValues[i])
94        );
95      }
96      thereExistsAccountCategory (
97        operator,
98        arrayAsList
99      );
100   }
101 
102   public void orderByAccountCategory (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:account1:AbstractAccount:accountCategory",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112 // Filter/ImplAttributeIsNotStruct
113 // ----------------------------------------------------------------------------
114   public void forAllAccountRating (
115     short operator,
116     java.util.Collection   values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:account1:AbstractAccount:accountRating",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125 
126   public void thereExistsAccountRating (
127     short operator,
128     java.util.Collection   values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:account1:AbstractAccount:accountRating",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137 
138   public void forAllAccountRating (
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     forAllAccountRating (
149       operator,
150       arrayAsList
151     );
152   }
153 
154   public void thereExistsAccountRating (
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     thereExistsAccountRating (
165       operator,
166       arrayAsList
167     );
168   }
169 
170   public void orderByAccountRating (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:account1:AbstractAccount:accountRating",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180 // Filter/ImplAttributeIsNotStruct
181 // ----------------------------------------------------------------------------
182   public void forAllAccountState (
183     short operator,
184     java.util.Collection   values
185   ) {
186     refAddValue(
187       "org:opencrx:kernel:account1:AbstractAccount:accountState",
188       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
189       operator,
190       values
191     );
192   }
193 
194   public void thereExistsAccountState (
195     short operator,
196     java.util.Collection   values
197   ) {
198     refAddValue(
199       "org:opencrx:kernel:account1:AbstractAccount:accountState",
200       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
201       operator,
202       values
203     );
204   }
205 
206   public void forAllAccountState (
207     short operator,
208     short[] filterValues
209   ) {
210     java.util.List   arrayAsList = new java.util.ArrayList  ();
211     for(int i = 0; i < filterValues.length; i++) {
212       arrayAsList.add(
213         new Short  (filterValues[i])
214       );
215     }
216     forAllAccountState (
217       operator,
218       arrayAsList
219     );
220   }
221 
222   public void thereExistsAccountState (
223     short operator,
224     short[] filterValues
225   ) {
226     java.util.List   arrayAsList = new java.util.ArrayList  ();
227     for(int i = 0; i < filterValues.length; i++) {
228       arrayAsList.add(
229         new Short  (filterValues[i])
230       );
231     }
232     thereExistsAccountState (
233       operator,
234       arrayAsList
235     );
236   }
237 
238   public void orderByAccountState (
239     short order
240   ) {
241     refAddValue(
242       "org:opencrx:kernel:account1:AbstractAccount:accountState",
243       order
244     );
245   }
246       
247 // ----------------------------------------------------------------------------
248 // Filter/ImplAttributeIsNotStruct
249 // ----------------------------------------------------------------------------
250   public void forAllAccountType (
251     short operator,
252     java.util.Collection   values
253   ) {
254     refAddValue(
255       "org:opencrx:kernel:account1:AbstractAccount:accountType",
256       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
257       operator,
258       values
259     );
260   }
261 
262   public void thereExistsAccountType (
263     short operator,
264     java.util.Collection   values
265   ) {
266     refAddValue(
267       "org:opencrx:kernel:account1:AbstractAccount:accountType",
268       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
269       operator,
270       values
271     );
272   }
273 
274   public void forAllAccountType (
275     short operator,
276     short[] filterValues
277   ) {
278     java.util.List   arrayAsList = new java.util.ArrayList  ();
279     for(int i = 0; i < filterValues.length; i++) {
280       arrayAsList.add(
281         new Short  (filterValues[i])
282       );
283     }
284     forAllAccountType (
285       operator,
286       arrayAsList
287     );
288   }
289 
290   public void thereExistsAccountType (
291     short operator,
292     short[] filterValues
293   ) {
294     java.util.List   arrayAsList = new java.util.ArrayList  ();
295     for(int i = 0; i < filterValues.length; i++) {
296       arrayAsList.add(
297         new Short  (filterValues[i])
298       );
299     }
300     thereExistsAccountType (
301       operator,
302       arrayAsList
303     );
304   }
305 
306   public void orderByAccountType (
307     short order
308   ) {
309     refAddValue(
310       "org:opencrx:kernel:account1:AbstractAccount:accountType",
311       order
312     );
313   }
314       
315 // ----------------------------------------------------------------------------
316 // Filter/ImplAttributeIsNotStruct
317 // ----------------------------------------------------------------------------
318   public void forAllAliasName (
319     short operator,
320     java.util.Collection   values
321   ) {
322     refAddValue(
323       "org:opencrx:kernel:account1:AbstractAccount:aliasName",
324       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
325       operator,
326       values
327     );
328   }
329 
330   public void thereExistsAliasName (
331     short operator,
332     java.util.Collection   values
333   ) {
334     refAddValue(
335       "org:opencrx:kernel:account1:AbstractAccount:aliasName",
336       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
337       operator,
338       values
339     );
340   }
341 
342   public void forAllAliasName (
343     short operator,
344     String  [] filterValues
345   ) {
346     java.util.List   arrayAsList = new java.util.ArrayList  ();
347     for(int i = 0; i < filterValues.length; i++) {
348       arrayAsList.add(
349         filterValues[i]
350       );
351     }
352     forAllAliasName (
353       operator,
354       arrayAsList
355     );
356   }
357 
358   public void thereExistsAliasName (
359     short operator,
360     String  [] filterValues
361   ) {
362     java.util.List   arrayAsList = new java.util.ArrayList  ();
363     for(int i = 0; i < filterValues.length; i++) {
364       arrayAsList.add(
365         filterValues[i]
366       );
367     }
368     thereExistsAliasName (
369       operator,
370       arrayAsList
371     );
372   }
373 
374   public void orderByAliasName (
375     short order
376   ) {
377     refAddValue(
378       "org:opencrx:kernel:account1:AbstractAccount:aliasName",
379       order
380     );
381   }
382       
383 // ----------------------------------------------------------------------------
384 // Filter/ImplAttributeIsNotStruct
385 // ----------------------------------------------------------------------------
386   public void forAllBusinessType (
387     short operator,
388     java.util.Collection   values
389   ) {
390     refAddValue(
391       "org:opencrx:kernel:account1:AbstractAccount:businessType",
392       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
393       operator,
394       values
395     );
396   }
397 
398   public void thereExistsBusinessType (
399     short operator,
400     java.util.Collection   values
401   ) {
402     refAddValue(
403       "org:opencrx:kernel:account1:AbstractAccount:businessType",
404       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
405       operator,
406       values
407     );
408   }
409 
410   public void forAllBusinessType (
411     short operator,
412     short[] filterValues
413   ) {
414     java.util.List   arrayAsList = new java.util.ArrayList  ();
415     for(int i = 0; i < filterValues.length; i++) {
416       arrayAsList.add(
417         new Short  (filterValues[i])
418       );
419     }
420     forAllBusinessType (
421       operator,
422       arrayAsList
423     );
424   }
425 
426   public void thereExistsBusinessType (
427     short operator,
428     short[] filterValues
429   ) {
430     java.util.List   arrayAsList = new java.util.ArrayList  ();
431     for(int i = 0; i < filterValues.length; i++) {
432       arrayAsList.add(
433         new Short  (filterValues[i])
434       );
435     }
436     thereExistsBusinessType (
437       operator,
438       arrayAsList
439     );
440   }
441 
442   public void orderByBusinessType (
443     short order
444   ) {
445     refAddValue(
446       "org:opencrx:kernel:account1:AbstractAccount:businessType",
447       order
448     );
449   }
450       
451 // ----------------------------------------------------------------------------
452 // Filter/ImplAttributeIsNotStruct
453 // ----------------------------------------------------------------------------
454   public void forAllDescription (
455     short operator,
456     java.util.Collection   values
457   ) {
458     refAddValue(
459       "org:opencrx:kernel:account1:AbstractAccount:description",
460       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
461       operator,
462       values
463     );
464   }
465 
466   public void thereExistsDescription (
467     short operator,
468     java.util.Collection   values
469   ) {
470     refAddValue(
471       "org:opencrx:kernel:account1:AbstractAccount:description",
472       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
473       operator,
474       values
475     );
476   }
477 
478   public void forAllDescription (
479     short operator,
480     String  [] filterValues
481   ) {
482     java.util.List   arrayAsList = new java.util.ArrayList  ();
483     for(int i = 0; i < filterValues.length; i++) {
484       arrayAsList.add(
485         filterValues[i]
486       );
487     }
488     forAllDescription (
489       operator,
490       arrayAsList
491     );
492   }
493 
494   public void thereExistsDescription (
495     short operator,
496     String  [] filterValues
497   ) {
498     java.util.List   arrayAsList = new java.util.ArrayList  ();
499     for(int i = 0; i < filterValues.length; i++) {
500       arrayAsList.add(
501         filterValues[i]
502       );
503     }
504     thereExistsDescription (
505       operator,
506       arrayAsList
507     );
508   }
509 
510   public void orderByDescription (
511     short order
512   ) {
513     refAddValue(
514       "org:opencrx:kernel:account1:AbstractAccount:description",
515       order
516     );
517   }
518       
519 // ----------------------------------------------------------------------------
520 // Filter/ImplAttributeIsNotStruct
521 // ----------------------------------------------------------------------------
522   public void forAllFullName (
523     short operator,
524     java.util.Collection   values
525   ) {
526     refAddValue(
527       "org:opencrx:kernel:account1:AbstractAccount:fullName",
528       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
529       operator,
530       values
531     );
532   }
533 
534   public void thereExistsFullName (
535     short operator,
536     java.util.Collection   values
537   ) {
538     refAddValue(
539       "org:opencrx:kernel:account1:AbstractAccount:fullName",
540       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
541       operator,
542       values
543     );
544   }
545 
546   public void forAllFullName (
547     short operator,
548     String  [] filterValues
549   ) {
550     java.util.List   arrayAsList = new java.util.ArrayList  ();
551     for(int i = 0; i < filterValues.length; i++) {
552       arrayAsList.add(
553         filterValues[i]
554       );
555     }
556     forAllFullName (
557       operator,
558       arrayAsList
559     );
560   }
561 
562   public void thereExistsFullName (
563     short operator,
564     String  [] filterValues
565   ) {
566     java.util.List   arrayAsList = new java.util.ArrayList  ();
567     for(int i = 0; i < filterValues.length; i++) {
568       arrayAsList.add(
569         filterValues[i]
570       );
571     }
572     thereExistsFullName (
573       operator,
574       arrayAsList
575     );
576   }
577 
578   public void orderByFullName (
579     short order
580   ) {
581     refAddValue(
582       "org:opencrx:kernel:account1:AbstractAccount:fullName",
583       order
584     );
585   }
586       
587 // ----------------------------------------------------------------------------
588 // Filter/ImplReference
589 // ----------------------------------------------------------------------------
590   public void forAllContact (
591     short operator,
592     org.opencrx.kernel.account1.cci.Contact[] filterValues
593   ) {
594     java.util.List   arrayAsList = new java.util.ArrayList  ();
595     for(int i = 0; i < filterValues.length; i++) {
596       arrayAsList.add(
597         filterValues[i]
598       );
599     }
600     forAllContact (
601       operator,
602       arrayAsList
603     );
604   }
605 
606   public void thereExistsContact (
607     short operator,
608     org.opencrx.kernel.account1.cci.Contact[] filterValues
609   ) {
610     java.util.List   arrayAsList = new java.util.ArrayList  ();
611     for(int i = 0; i < filterValues.length; i++) {
612       arrayAsList.add(
613         filterValues[i]
614       );
615     }
616     thereExistsContact (
617       operator,
618       arrayAsList
619     );
620   }
621 
622   public void forAllContact (
623     short operator,
624     java.util.Collection   values
625   ) {
626     refAddValue(
627       "org:opencrx:kernel:account1:Account:contact",
628       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
629       operator,
630       values
631     );
632   }
633 
634   public void thereExistsContact (
635     short operator,
636     java.util.Collection   values
637   ) {
638     refAddValue(
639       "org:opencrx:kernel:account1:Account:contact",
640       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
641       operator,
642       values
643     );
644   }
645       
646 // ----------------------------------------------------------------------------
647 // Filter/ImplReference
648 // ----------------------------------------------------------------------------
649   public void forAllPartner (
650     short operator,
651     org.opencrx.kernel.account1.cci.Account[] filterValues
652   ) {
653     java.util.List   arrayAsList = new java.util.ArrayList  ();
654     for(int i = 0; i < filterValues.length; i++) {
655       arrayAsList.add(
656         filterValues[i]
657       );
658     }
659     forAllPartner (
660       operator,
661       arrayAsList
662     );
663   }
664 
665   public void thereExistsPartner (
666     short operator,
667     org.opencrx.kernel.account1.cci.Account[] filterValues
668   ) {
669     java.util.List   arrayAsList = new java.util.ArrayList  ();
670     for(int i = 0; i < filterValues.length; i++) {
671       arrayAsList.add(
672         filterValues[i]
673       );
674     }
675     thereExistsPartner (
676       operator,
677       arrayAsList
678     );
679   }
680 
681   public void forAllPartner (
682     short operator,
683     java.util.Collection   values
684   ) {
685     refAddValue(
686       "org:opencrx:kernel:account1:Account:partner",
687       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
688       operator,
689       values
690     );
691   }
692 
693   public void thereExistsPartner (
694     short operator,
695     java.util.Collection   values
696   ) {
697     refAddValue(
698       "org:opencrx:kernel:account1:Account:partner",
699       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
700       operator,
701       values
702     );
703   }
704       
705 // ----------------------------------------------------------------------------
706 // Filter/ImplAttributeIsNotStruct
707 // ----------------------------------------------------------------------------
708   public void forAllAnniversary (
709     short operator,
710     java.util.Collection   values
711   ) {
712     refAddValue(
713       "org:opencrx:kernel:account1:Contact:anniversary",
714       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
715       operator,
716       values
717     );
718   }
719 
720   public void thereExistsAnniversary (
721     short operator,
722     java.util.Collection   values
723   ) {
724     refAddValue(
725       "org:opencrx:kernel:account1:Contact:anniversary",
726       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
727       operator,
728       values
729     );
730   }
731 
732   public void forAllAnniversary (
733     short operator,
734     java.util.Date  [] filterValues
735   ) {
736     java.util.List   arrayAsList = new java.util.ArrayList  ();
737     for(int i = 0; i < filterValues.length; i++) {
738       arrayAsList.add(
739         filterValues[i]
740       );
741     }
742     forAllAnniversary (
743       operator,
744       arrayAsList
745     );
746   }
747 
748   public void thereExistsAnniversary (
749     short operator,
750     java.util.Date  [] filterValues
751   ) {
752     java.util.List   arrayAsList = new java.util.ArrayList  ();
753     for(int i = 0; i < filterValues.length; i++) {
754       arrayAsList.add(
755         filterValues[i]
756       );
757     }
758     thereExistsAnniversary (
759       operator,
760       arrayAsList
761     );
762   }
763 
764   public void orderByAnniversary (
765     short order
766   ) {
767     refAddValue(
768       "org:opencrx:kernel:account1:Contact:anniversary",
769       order
770     );
771   }
772       
773 // ----------------------------------------------------------------------------
774 // Filter/ImplAttributeIsNotStruct
775 // ----------------------------------------------------------------------------
776   public void forAllAnnualIncomeAmount (
777     short operator,
778     java.util.Collection   values
779   ) {
780     refAddValue(
781       "org:opencrx:kernel:account1:Contact:annualIncomeAmount",
782       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
783       operator,
784       values
785     );
786   }
787 
788   public void thereExistsAnnualIncomeAmount (
789     short operator,
790     java.util.Collection   values
791   ) {
792     refAddValue(
793       "org:opencrx:kernel:account1:Contact:annualIncomeAmount",
794       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
795       operator,
796       values
797     );
798   }
799 
800   public void forAllAnnualIncomeAmount (
801     short operator,
802     java.math.BigDecimal  [] filterValues
803   ) {
804     java.util.List   arrayAsList = new java.util.ArrayList  ();
805     for(int i = 0; i < filterValues.length; i++) {
806       arrayAsList.add(
807         filterValues[i]
808       );
809     }
810     forAllAnnualIncomeAmount (
811       operator,
812       arrayAsList
813     );
814   }
815 
816   public void thereExistsAnnualIncomeAmount (
817     short operator,
818     java.math.BigDecimal  [] filterValues
819   ) {
820     java.util.List   arrayAsList = new java.util.ArrayList  ();
821     for(int i = 0; i < filterValues.length; i++) {
822       arrayAsList.add(
823         filterValues[i]
824       );
825     }
826     thereExistsAnnualIncomeAmount (
827       operator,
828       arrayAsList
829     );
830   }
831 
832   public void orderByAnnualIncomeAmount (
833     short order
834   ) {
835     refAddValue(
836       "org:opencrx:kernel:account1:Contact:annualIncomeAmount",
837       order
838     );
839   }
840       
841 // ----------------------------------------------------------------------------
842 // Filter/ImplAttributeIsNotStruct
843 // ----------------------------------------------------------------------------
844   public void forAllAnnualIncomeCurrency (
845     short operator,
846     java.util.Collection   values
847   ) {
848     refAddValue(
849       "org:opencrx:kernel:account1:Contact:annualIncomeCurrency",
850       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
851       operator,
852       values
853     );
854   }
855 
856   public void thereExistsAnnualIncomeCurrency (
857     short operator,
858     java.util.Collection   values
859   ) {
860     refAddValue(
861       "org:opencrx:kernel:account1:Contact:annualIncomeCurrency",
862       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
863       operator,
864       values
865     );
866   }
867 
868   public void forAllAnnualIncomeCurrency (
869     short operator,
870     short[] filterValues
871   ) {
872     java.util.List   arrayAsList = new java.util.ArrayList  ();
873     for(int i = 0; i < filterValues.length; i++) {
874       arrayAsList.add(
875         new Short  (filterValues[i])
876       );
877     }
878     forAllAnnualIncomeCurrency (
879       operator,
880       arrayAsList
881     );
882   }
883 
884   public void thereExistsAnnualIncomeCurrency (
885     short operator,
886     short[] filterValues
887   ) {
888     java.util.List   arrayAsList = new java.util.ArrayList  ();
889     for(int i = 0; i < filterValues.length; i++) {
890       arrayAsList.add(
891         new Short  (filterValues[i])
892       );
893     }
894     thereExistsAnnualIncomeCurrency (
895       operator,
896       arrayAsList
897     );
898   }
899 
900   public void orderByAnnualIncomeCurrency (
901     short order
902   ) {
903     refAddValue(
904       "org:opencrx:kernel:account1:Contact:annualIncomeCurrency",
905       order
906     );
907   }
908       
909 // ----------------------------------------------------------------------------
910 // Filter/ImplReference
911 // ----------------------------------------------------------------------------
912   public void forAllAssistant (
913     short operator,
914     org.opencrx.kernel.account1.cci.Account[] filterValues
915   ) {
916     java.util.List   arrayAsList = new java.util.ArrayList  ();
917     for(int i = 0; i < filterValues.length; i++) {
918       arrayAsList.add(
919         filterValues[i]
920       );
921     }
922     forAllAssistant (
923       operator,
924       arrayAsList
925     );
926   }
927 
928   public void thereExistsAssistant (
929     short operator,
930     org.opencrx.kernel.account1.cci.Account[] filterValues
931   ) {
932     java.util.List   arrayAsList = new java.util.ArrayList  ();
933     for(int i = 0; i < filterValues.length; i++) {
934       arrayAsList.add(
935         filterValues[i]
936       );
937     }
938     thereExistsAssistant (
939       operator,
940       arrayAsList
941     );
942   }
943 
944   public void forAllAssistant (
945     short operator,
946     java.util.Collection   values
947   ) {
948     refAddValue(
949       "org:opencrx:kernel:account1:Contact:assistant",
950       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
951       operator,
952       values
953     );
954   }
955 
956   public void thereExistsAssistant (
957     short operator,
958     java.util.Collection   values
959   ) {
960     refAddValue(
961       "org:opencrx:kernel:account1:Contact:assistant",
962       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
963       operator,
964       values
965     );
966   }
967       
968 // ----------------------------------------------------------------------------
969 // Filter/ImplAttributeIsNotStruct
970 // ----------------------------------------------------------------------------
971   public void forAllBirthdate (
972     short operator,
973     java.util.Collection   values
974   ) {
975     refAddValue(
976       "org:opencrx:kernel:account1:Contact:birthdate",
977       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
978       operator,
979       values
980     );
981   }
982 
983   public void thereExistsBirthdate (
984     short operator,
985     java.util.Collection   values
986   ) {
987     refAddValue(
988       "org:opencrx:kernel:account1:Contact:birthdate",
989       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
990       operator,
991       values
992     );
993   }
994 
995   public void forAllBirthdate (
996     short operator,
997     java.util.Date  [] filterValues
998   ) {
999     java.util.List   arrayAsList = new java.util.ArrayList  ();
1000    for(int i = 0; i < filterValues.length; i++) {
1001      arrayAsList.add(
1002        filterValues[i]
1003      );
1004    }
1005    forAllBirthdate (
1006      operator,
1007      arrayAsList
1008    );
1009  }
1010
1011  public void thereExistsBirthdate (
1012    short operator,
1013    java.util.Date  [] filterValues
1014  ) {
1015    java.util.List   arrayAsList = new java.util.ArrayList  ();
1016    for(int i = 0; i < filterValues.length; i++) {
1017      arrayAsList.add(
1018        filterValues[i]
1019      );
1020    }
1021    thereExistsBirthdate (
1022      operator,
1023      arrayAsList
1024    );
1025  }
1026
1027  public void orderByBirthdate (
1028    short order
1029  ) {
1030    refAddValue(
1031      "org:opencrx:kernel:account1:Contact:birthdate",
1032      order
1033    );
1034  }
1035      
1036// ----------------------------------------------------------------------------
1037// Filter/ImplAttributeIsNotStruct
1038// ----------------------------------------------------------------------------
1039  public void forAllChildrenNames (
1040    short operator,
1041    java.util.Collection   values
1042  ) {
1043    refAddValue(
1044      "org:opencrx:kernel:account1:Contact:childrenNames",
1045      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1046      operator,
1047      values
1048    );
1049  }
1050
1051  public void thereExistsChildrenNames (
1052    short operator,
1053    java.util.Collection   values
1054  ) {
1055    refAddValue(
1056      "org:opencrx:kernel:account1:Contact:childrenNames",
1057      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1058      operator,
1059      values
1060    );
1061  }
1062
1063  public void forAllChildrenNames (
1064    short operator,
1065    String  [] filterValues
1066  ) {
1067    java.util.List   arrayAsList = new java.util.ArrayList  ();
1068    for(int i = 0; i < filterValues.length; i++) {
1069      arrayAsList.add(
1070        filterValues[i]
1071      );
1072    }
1073    forAllChildrenNames (
1074      operator,
1075      arrayAsList
1076    );
1077  }
1078
1079  public void thereExistsChildrenNames (
1080    short operator,
1081    String  [] filterValues
1082  ) {
1083    java.util.List   arrayAsList = new java.util.ArrayList  ();
1084    for(int i = 0; i < filterValues.length; i++) {
1085      arrayAsList.add(
1086        filterValues[i]
1087      );
1088    }
1089    thereExistsChildrenNames (
1090      operator,
1091      arrayAsList
1092    );
1093  }
1094
1095  public void orderByChildrenNames (
1096    short order
1097  ) {
1098    refAddValue(
1099      "org:opencrx:kernel:account1:Contact:childrenNames",
1100      order
1101    );
1102  }
1103      
1104// ----------------------------------------------------------------------------
1105// Filter/ImplAttributeIsNotStruct
1106// ----------------------------------------------------------------------------
1107  public void forAllDepartment (
1108    short operator,
1109    java.util.Collection   values
1110  ) {
1111    refAddValue(
1112      "org:opencrx:kernel:account1:Contact:department",
1113      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1114      operator,
1115      values
1116    );
1117  }
1118
1119  public void thereExistsDepartment (
1120    short operator,
1121    java.util.Collection   values
1122  ) {
1123    refAddValue(
1124      "org:opencrx:kernel:account1:Contact:department",
1125      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1126      operator,
1127      values
1128    );
1129  }
1130
1131  public void forAllDepartment (
1132    short operator,
1133    String  [] filterValues
1134  ) {
1135    java.util.List   arrayAsList = new java.util.ArrayList  ();
1136    for(int i = 0; i < filterValues.length; i++) {
1137      arrayAsList.add(
1138        filterValues[i]
1139      );
1140    }
1141    forAllDepartment (
1142      operator,
1143      arrayAsList
1144    );
1145  }
1146
1147  public void thereExistsDepartment (
1148    short operator,
1149    String  [] filterValues
1150  ) {
1151    java.util.List   arrayAsList = new java.util.ArrayList  ();
1152    for(int i = 0; i < filterValues.length; i++) {
1153      arrayAsList.add(
1154        filterValues[i]
1155      );
1156    }
1157    thereExistsDepartment (
1158      operator,
1159      arrayAsList
1160    );
1161  }
1162
1163  public void orderByDepartment (
1164    short order
1165  ) {
1166    refAddValue(
1167      "org:opencrx:kernel:account1:Contact:department",
1168      order
1169    );
1170  }
1171      
1172// ----------------------------------------------------------------------------
1173// Filter/ImplReference
1174// ----------------------------------------------------------------------------
1175  public void forAllDeputy (
1176    short operator,
1177    org.opencrx.kernel.account1.cci.Account[] filterValues
1178  ) {
1179    java.util.List   arrayAsList = new java.util.ArrayList  ();
1180    for(int i = 0; i < filterValues.length; i++) {
1181      arrayAsList.add(
1182        filterValues[i]
1183      );
1184    }
1185    forAllDeputy (
1186      operator,
1187      arrayAsList
1188    );
1189  }
1190
1191  public void thereExistsDeputy (
1192    short operator,
1193    org.opencrx.kernel.account1.cci.Account[] filterValues
1194  ) {
1195    java.util.List   arrayAsList = new java.util.ArrayList  ();
1196    for(int i = 0; i < filterValues.length; i++) {
1197      arrayAsList.add(
1198        filterValues[i]
1199      );
1200    }
1201    thereExistsDeputy (
1202      operator,
1203      arrayAsList
1204    );
1205  }
1206
1207  public void forAllDeputy (
1208    short operator,
1209    java.util.Collection   values
1210  ) {
1211    refAddValue(
1212      "org:opencrx:kernel:account1:Contact:deputy",
1213      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1214      operator,
1215      values
1216    );
1217  }
1218
1219  public void thereExistsDeputy (
1220    short operator,
1221    java.util.Collection   values
1222  ) {
1223    refAddValue(
1224      "org:opencrx:kernel:account1:Contact:deputy",
1225      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1226      operator,
1227      values
1228    );
1229  }
1230      
1231// ----------------------------------------------------------------------------
1232// Filter/ImplAttributeIsNotStruct
1233// ----------------------------------------------------------------------------
1234  public void forAllDoNotBulkPostalMail (
1235    short operator,
1236    java.util.Collection   values
1237  ) {
1238    refAddValue(
1239      "org:opencrx:kernel:account1:Contact:doNotBulkPostalMail",
1240      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1241      operator,
1242      values
1243    );
1244  }
1245
1246  public void thereExistsDoNotBulkPostalMail (
1247    short operator,
1248    java.util.Collection   values
1249  ) {
1250    refAddValue(
1251      "org:opencrx:kernel:account1:Contact:doNotBulkPostalMail",
1252      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1253      operator,
1254      values
1255    );
1256  }
1257
1258  public void forAllDoNotBulkPostalMail (
1259    short operator,
1260    boolean[] 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 Boolean  (filterValues[i])
1266      );
1267    }
1268    forAllDoNotBulkPostalMail (
1269      operator,
1270      arrayAsList
1271    );
1272  }
1273
1274  public void thereExistsDoNotBulkPostalMail (
1275    short operator,
1276    boolean[] 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 Boolean  (filterValues[i])
1282      );
1283    }
1284    thereExistsDoNotBulkPostalMail (
1285      operator,
1286      arrayAsList
1287    );
1288  }
1289
1290  public void orderByDoNotBulkPostalMail (
1291    short order
1292  ) {
1293    refAddValue(
1294      "org:opencrx:kernel:account1:Contact:doNotBulkPostalMail",
1295      order
1296    );
1297  }
1298      
1299// ----------------------------------------------------------------------------
1300// Filter/ImplAttributeIsNotStruct
1301// ----------------------------------------------------------------------------
1302  public void forAllDoNotEMail (
1303    short operator,
1304    java.util.Collection   values
1305  ) {
1306    refAddValue(
1307      "org:opencrx:kernel:account1:Contact:doNotEMail",
1308      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1309      operator,
1310      values
1311    );
1312  }
1313
1314  public void thereExistsDoNotEMail (
1315    short operator,
1316    java.util.Collection   values
1317  ) {
1318    refAddValue(
1319      "org:opencrx:kernel:account1:Contact:doNotEMail",
1320      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1321      operator,
1322      values
1323    );
1324  }
1325
1326  public void forAllDoNotEMail (
1327    short operator,
1328    boolean[] 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 Boolean  (filterValues[i])
1334      );
1335    }
1336    forAllDoNotEMail (
1337      operator,
1338      arrayAsList
1339    );
1340  }
1341
1342  public void thereExistsDoNotEMail (
1343    short operator,
1344    boolean[] 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 Boolean  (filterValues[i])
1350      );
1351    }
1352    thereExistsDoNotEMail (
1353      operator,
1354      arrayAsList
1355    );
1356  }
1357
1358  public void orderByDoNotEMail (
1359    short order
1360  ) {
1361    refAddValue(
1362      "org:opencrx:kernel:account1:Contact:doNotEMail",
1363      order
1364    );
1365  }
1366      
1367// ----------------------------------------------------------------------------
1368// Filter/ImplAttributeIsNotStruct
1369// ----------------------------------------------------------------------------
1370  public void forAllDoNotFax (
1371    short operator,
1372    java.util.Collection   values
1373  ) {
1374    refAddValue(
1375      "org:opencrx:kernel:account1:Contact:doNotFax",
1376      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1377      operator,
1378      values
1379    );
1380  }
1381
1382  public void thereExistsDoNotFax (
1383    short operator,
1384    java.util.Collection   values
1385  ) {
1386    refAddValue(
1387      "org:opencrx:kernel:account1:Contact:doNotFax",
1388      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1389      operator,
1390      values
1391    );
1392  }
1393
1394  public void forAllDoNotFax (
1395    short operator,
1396    boolean[] filterValues
1397  ) {
1398    java.util.List   arrayAsList = new java.util.ArrayList  ();
1399    for(int i = 0; i < filterValues.length; i++) {
1400      arrayAsList.add(
1401        new Boolean  (filterValues[i])
1402      );
1403    }
1404    forAllDoNotFax (
1405      operator,
1406      arrayAsList
1407    );
1408  }
1409
1410  public void thereExistsDoNotFax (
1411    short operator,
1412    boolean[] filterValues
1413  ) {
1414    java.util.List   arrayAsList = new java.util.ArrayList  ();
1415    for(int i = 0; i < filterValues.length; i++) {
1416      arrayAsList.add(
1417        new Boolean  (filterValues[i])
1418      );
1419    }
1420    thereExistsDoNotFax (
1421      operator,
1422      arrayAsList
1423    );
1424  }
1425
1426  public void orderByDoNotFax (
1427    short order
1428  ) {
1429    refAddValue(
1430      "org:opencrx:kernel:account1:Contact:doNotFax",
1431      order
1432    );
1433  }
1434      
1435// ----------------------------------------------------------------------------
1436// Filter/ImplAttributeIsNotStruct
1437// ----------------------------------------------------------------------------
1438  public void forAllDoNotPhone (
1439    short operator,
1440    java.util.Collection   values
1441  ) {
1442    refAddValue(
1443      "org:opencrx:kernel:account1:Contact:doNotPhone",
1444      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1445      operator,
1446      values
1447    );
1448  }
1449
1450  public void thereExistsDoNotPhone (
1451    short operator,
1452    java.util.Collection   values
1453  ) {
1454    refAddValue(
1455      "org:opencrx:kernel:account1:Contact:doNotPhone",
1456      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1457      operator,
1458      values
1459    );
1460  }
1461
1462  public void forAllDoNotPhone (
1463    short operator,
1464    boolean[] filterValues
1465  ) {
1466    java.util.List   arrayAsList = new java.util.ArrayList  ();
1467    for(int i = 0; i < filterValues.length; i++) {
1468      arrayAsList.add(
1469        new Boolean  (filterValues[i])
1470      );
1471    }
1472    forAllDoNotPhone (
1473      operator,
1474      arrayAsList
1475    );
1476  }
1477
1478  public void thereExistsDoNotPhone (
1479    short operator,
1480    boolean[] filterValues
1481  ) {
1482    java.util.List   arrayAsList = new java.util.ArrayList  ();
1483    for(int i = 0; i < filterValues.length; i++) {
1484      arrayAsList.add(
1485        new Boolean  (filterValues[i])
1486      );
1487    }
1488    thereExistsDoNotPhone (
1489      operator,
1490      arrayAsList
1491    );
1492  }
1493
1494  public void orderByDoNotPhone (
1495    short order
1496  ) {
1497    refAddValue(
1498      "org:opencrx:kernel:account1:Contact:doNotPhone",
1499      order
1500    );
1501  }
1502      
1503// ----------------------------------------------------------------------------
1504// Filter/ImplAttributeIsNotStruct
1505// ----------------------------------------------------------------------------
1506  public void forAllDoNotPostalMail (
1507    short operator,
1508    java.util.Collection   values
1509  ) {
1510    refAddValue(
1511      "org:opencrx:kernel:account1:Contact:doNotPostalMail",
1512      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1513      operator,
1514      values
1515    );
1516  }
1517
1518  public void thereExistsDoNotPostalMail (
1519    short operator,
1520    java.util.Collection   values
1521  ) {
1522    refAddValue(
1523      "org:opencrx:kernel:account1:Contact:doNotPostalMail",
1524      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1525      operator,
1526      values
1527    );
1528  }
1529
1530  public void forAllDoNotPostalMail (
1531    short operator,
1532    boolean[] filterValues
1533  ) {
1534    java.util.List   arrayAsList = new java.util.ArrayList  ();
1535    for(int i = 0; i < filterValues.length; i++) {
1536      arrayAsList.add(
1537        new Boolean  (filterValues[i])
1538      );
1539    }
1540    forAllDoNotPostalMail (
1541      operator,
1542      arrayAsList
1543    );
1544  }
1545
1546  public void thereExistsDoNotPostalMail (
1547    short operator,
1548    boolean[] filterValues
1549  ) {
1550    java.util.List   arrayAsList = new java.util.ArrayList  ();
1551    for(int i = 0; i < filterValues.length; i++) {
1552      arrayAsList.add(
1553        new Boolean  (filterValues[i])
1554      );
1555    }
1556    thereExistsDoNotPostalMail (
1557      operator,
1558      arrayAsList
1559    );
1560  }
1561
1562  public void orderByDoNotPostalMail (
1563    short order
1564  ) {
1565    refAddValue(
1566      "org:opencrx:kernel:account1:Contact:doNotPostalMail",
1567      order
1568    );
1569  }
1570      
1571// ----------------------------------------------------------------------------
1572// Filter/ImplAttributeIsNotStruct
1573// ----------------------------------------------------------------------------
1574  public void forAllEducation (
1575    short operator,
1576    java.util.Collection   values
1577  ) {
1578    refAddValue(
1579      "org:opencrx:kernel:account1:Contact:education",
1580      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1581      operator,
1582      values
1583    );
1584  }
1585
1586  public void thereExistsEducation (
1587    short operator,
1588    java.util.Collection   values
1589  ) {
1590    refAddValue(
1591      "org:opencrx:kernel:account1:Contact:education",
1592      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1593      operator,
1594      values
1595    );
1596  }
1597
1598  public void forAllEducation (
1599    short operator,
1600    short[] filterValues
1601  ) {
1602    java.util.List   arrayAsList = new java.util.ArrayList  ();
1603    for(int i = 0; i < filterValues.length; i++) {
1604      arrayAsList.add(
1605        new Short  (filterValues[i])
1606      );
1607    }
1608    forAllEducation (
1609      operator,
1610      arrayAsList
1611    );
1612  }
1613
1614  public void thereExistsEducation (
1615    short operator,
1616    short[] filterValues
1617  ) {
1618    java.util.List   arrayAsList = new java.util.ArrayList  ();
1619    for(int i = 0; i < filterValues.length; i++) {
1620      arrayAsList.add(
1621        new Short  (filterValues[i])
1622      );
1623    }
1624    thereExistsEducation (
1625      operator,
1626      arrayAsList
1627    );
1628  }
1629
1630  public void orderByEducation (
1631    short order
1632  ) {
1633    refAddValue(
1634      "org:opencrx:kernel:account1:Contact:education",
1635      order
1636    );
1637  }
1638      
1639// ----------------------------------------------------------------------------
1640// Filter/ImplAttributeIsNotStruct
1641// ----------------------------------------------------------------------------
1642  public void forAllFamilyStatus (
1643    short operator,
1644    java.util.Collection   values
1645  ) {
1646    refAddValue(
1647      "org:opencrx:kernel:account1:Contact:familyStatus",
1648      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1649      operator,
1650      values
1651    );
1652  }
1653
1654  public void thereExistsFamilyStatus (
1655    short operator,
1656    java.util.Collection   values
1657  ) {
1658    refAddValue(
1659      "org:opencrx:kernel:account1:Contact:familyStatus",
1660      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1661      operator,
1662      values
1663    );
1664  }
1665
1666  public void forAllFamilyStatus (
1667    short operator,
1668    short[] filterValues
1669  ) {
1670    java.util.List   arrayAsList = new java.util.ArrayList  ();
1671    for(int i = 0; i < filterValues.length; i++) {
1672      arrayAsList.add(
1673        new Short  (filterValues[i])
1674      );
1675    }
1676    forAllFamilyStatus (
1677      operator,
1678      arrayAsList
1679    );
1680  }
1681
1682  public void thereExistsFamilyStatus (
1683    short operator,
1684    short[] filterValues
1685  ) {
1686    java.util.List   arrayAsList = new java.util.ArrayList  ();
1687    for(int i = 0; i < filterValues.length; i++) {
1688      arrayAsList.add(
1689        new Short  (filterValues[i])
1690      );
1691    }
1692    thereExistsFamilyStatus (
1693      operator,
1694      arrayAsList
1695    );
1696  }
1697
1698  public void orderByFamilyStatus (
1699    short order
1700  ) {
1701    refAddValue(
1702      "org:opencrx:kernel:account1:Contact:familyStatus",
1703      order
1704    );
1705  }
1706      
1707// ----------------------------------------------------------------------------
1708// Filter/ImplAttributeIsNotStruct
1709// ----------------------------------------------------------------------------
1710  public void forAllFirstName (
1711    short operator,
1712    java.util.Collection   values
1713  ) {
1714    refAddValue(
1715      "org:opencrx:kernel:account1:Contact:firstName",
1716      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1717      operator,
1718      values
1719    );
1720  }
1721
1722  public void thereExistsFirstName (
1723    short operator,
1724    java.util.Collection   values
1725  ) {
1726    refAddValue(
1727      "org:opencrx:kernel:account1:Contact:firstName",
1728      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1729      operator,
1730      values
1731    );
1732  }
1733
1734  public void forAllFirstName (
1735    short operator,
1736    String  [] filterValues
1737  ) {
1738    java.util.List   arrayAsList = new java.util.ArrayList  ();
1739    for(int i = 0; i < filterValues.length; i++) {
1740      arrayAsList.add(
1741        filterValues[i]
1742      );
1743    }
1744    forAllFirstName (
1745      operator,
1746      arrayAsList
1747    );
1748  }
1749
1750  public void thereExistsFirstName (
1751    short operator,
1752    String  [] filterValues
1753  ) {
1754    java.util.List   arrayAsList = new java.util.ArrayList  ();
1755    for(int i = 0; i < filterValues.length; i++) {
1756      arrayAsList.add(
1757        filterValues[i]
1758      );
1759    }
1760    thereExistsFirstName (
1761      operator,
1762      arrayAsList
1763    );
1764  }
1765
1766  public void orderByFirstName (
1767    short order
1768  ) {
1769    refAddValue(
1770      "org:opencrx:kernel:account1:Contact:firstName",
1771      order
1772    );
1773  }
1774      
1775// ----------------------------------------------------------------------------
1776// Filter/ImplAttributeIsNotStruct
1777// ----------------------------------------------------------------------------
1778  public void forAllGender (
1779    short operator,
1780    java.util.Collection   values
1781  ) {
1782    refAddValue(
1783      "org:opencrx:kernel:account1:Contact:gender",
1784      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1785      operator,
1786      values
1787    );
1788  }
1789
1790  public void thereExistsGender (
1791    short operator,
1792    java.util.Collection   values
1793  ) {
1794    refAddValue(
1795      "org:opencrx:kernel:account1:Contact:gender",
1796      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1797      operator,
1798      values
1799    );
1800  }
1801
1802  public void forAllGender (
1803    short operator,
1804    short[] filterValues
1805  ) {
1806    java.util.List   arrayAsList = new java.util.ArrayList  ();
1807    for(int i = 0; i < filterValues.length; i++) {
1808      arrayAsList.add(
1809        new Short  (filterValues[i])
1810      );
1811    }
1812    forAllGender (
1813      operator,
1814      arrayAsList
1815    );
1816  }
1817
1818  public void thereExistsGender (
1819    short operator,
1820    short[] filterValues
1821  ) {
1822    java.util.List   arrayAsList = new java.util.ArrayList  ();
1823    for(int i = 0; i < filterValues.length; i++) {
1824      arrayAsList.add(
1825        new Short  (filterValues[i])
1826      );
1827    }
1828    thereExistsGender (
1829      operator,
1830      arrayAsList
1831    );
1832  }
1833
1834  public void orderByGender (
1835    short order
1836  ) {
1837    refAddValue(
1838      "org:opencrx:kernel:account1:Contact:gender",
1839      order
1840    );
1841  }
1842      
1843// ----------------------------------------------------------------------------
1844// Filter/ImplAttributeIsNotStruct
1845// ----------------------------------------------------------------------------
1846  public void forAllGovernmentId (
1847    short operator,
1848    java.util.Collection   values
1849  ) {
1850    refAddValue(
1851      "org:opencrx:kernel:account1:Contact:governmentId",
1852      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1853      operator,
1854      values
1855    );
1856  }
1857
1858  public void thereExistsGovernmentId (
1859    short operator,
1860    java.util.Collection   values
1861  ) {
1862    refAddValue(
1863      "org:opencrx:kernel:account1:Contact:governmentId",
1864      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1865      operator,
1866      values
1867    );
1868  }
1869
1870  public void forAllGovernmentId (
1871    short operator,
1872    String  [] filterValues
1873  ) {
1874    java.util.List   arrayAsList = new java.util.ArrayList  ();
1875    for(int i = 0; i < filterValues.length; i++) {
1876      arrayAsList.add(
1877        filterValues[i]
1878      );
1879    }
1880    forAllGovernmentId (
1881      operator,
1882      arrayAsList
1883    );
1884  }
1885
1886  public void thereExistsGovernmentId (
1887    short operator,
1888    String  [] filterValues
1889  ) {
1890    java.util.List   arrayAsList = new java.util.ArrayList  ();
1891    for(int i = 0; i < filterValues.length; i++) {
1892      arrayAsList.add(
1893        filterValues[i]
1894      );
1895    }
1896    thereExistsGovernmentId (
1897      operator,
1898      arrayAsList
1899    );
1900  }
1901
1902  public void orderByGovernmentId (
1903    short order
1904  ) {
1905    refAddValue(
1906      "org:opencrx:kernel:account1:Contact:governmentId",
1907      order
1908    );
1909  }
1910      
1911// ----------------------------------------------------------------------------
1912// Filter/ImplAttributeIsNotStruct
1913// ----------------------------------------------------------------------------
1914  public void forAllJobRole (
1915    short operator,
1916    java.util.Collection   values
1917  ) {
1918    refAddValue(
1919      "org:opencrx:kernel:account1:Contact:jobRole",
1920      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1921      operator,
1922      values
1923    );
1924  }
1925
1926  public void thereExistsJobRole (
1927    short operator,
1928    java.util.Collection   values
1929  ) {
1930    refAddValue(
1931      "org:opencrx:kernel:account1:Contact:jobRole",
1932      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1933      operator,
1934      values
1935    );
1936  }
1937
1938  public void forAllJobRole (
1939    short operator,
1940    String  [] filterValues
1941  ) {
1942    java.util.List   arrayAsList = new java.util.ArrayList  ();
1943    for(int i = 0; i < filterValues.length; i++) {
1944      arrayAsList.add(
1945        filterValues[i]
1946      );
1947    }
1948    forAllJobRole (
1949      operator,
1950      arrayAsList
1951    );
1952  }
1953
1954  public void thereExistsJobRole (
1955    short operator,
1956    String  [] filterValues
1957  ) {
1958    java.util.List   arrayAsList = new java.util.ArrayList  ();
1959    for(int i = 0; i < filterValues.length; i++) {
1960      arrayAsList.add(
1961        filterValues[i]
1962      );
1963    }
1964    thereExistsJobRole (
1965      operator,
1966      arrayAsList
1967    );
1968  }
1969
1970  public void orderByJobRole (
1971    short order
1972  ) {
1973    refAddValue(
1974      "org:opencrx:kernel:account1:Contact:jobRole",
1975      order
1976    );
1977  }
1978      
1979// ----------------------------------------------------------------------------
1980// Filter/ImplAttributeIsNotStruct
1981// ----------------------------------------------------------------------------
1982  public void forAllJobTitle (
1983    short operator,
1984    java.util.Collection   values
1985  ) {
1986    refAddValue(
1987      "org:opencrx:kernel:account1:Contact:jobTitle",
1988      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1989      operator,
1990      values
1991    );
1992  }
1993
1994  public void thereExistsJobTitle (
1995    short operator,
1996    java.util.Collection   values
1997  ) {
1998    refAddValue(
1999      "org:opencrx:kernel:account1:Contact:jobTitle",
2000      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2001      operator,
2002      values
2003    );
2004  }
2005
2006  public void forAllJobTitle (
2007    short operator,
2008    String  [] filterValues
2009  ) {
2010    java.util.List   arrayAsList = new java.util.ArrayList  ();
2011    for(int i = 0; i < filterValues.length; i++) {
2012      arrayAsList.add(
2013        filterValues[i]
2014      );
2015    }
2016    forAllJobTitle (
2017      operator,
2018      arrayAsList
2019    );
2020  }
2021
2022  public void thereExistsJobTitle (
2023    short operator,
2024    String  [] filterValues
2025  ) {
2026    java.util.List   arrayAsList = new java.util.ArrayList  ();
2027    for(int i = 0; i < filterValues.length; i++) {
2028      arrayAsList.add(
2029        filterValues[i]
2030      );
2031    }
2032    thereExistsJobTitle (
2033      operator,
2034      arrayAsList
2035    );
2036  }
2037
2038  public void orderByJobTitle (
2039    short order
2040  ) {
2041    refAddValue(
2042      "org:opencrx:kernel:account1:Contact:jobTitle",
2043      order
2044    );
2045  }
2046      
2047// ----------------------------------------------------------------------------
2048// Filter/ImplAttributeIsNotStruct
2049// ----------------------------------------------------------------------------
2050  public void forAllLastName (
2051    short operator,
2052    java.util.Collection   values
2053  ) {
2054    refAddValue(
2055      "org:opencrx:kernel:account1:Contact:lastName",
2056      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2057      operator,
2058      values
2059    );
2060  }
2061
2062  public void thereExistsLastName (
2063    short operator,
2064    java.util.Collection   values
2065  ) {
2066    refAddValue(
2067      "org:opencrx:kernel:account1:Contact:lastName",
2068      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2069      operator,
2070      values
2071    );
2072  }
2073
2074  public void forAllLastName (
2075    short operator,
2076    String  [] filterValues
2077  ) {
2078    java.util.List   arrayAsList = new java.util.ArrayList  ();
2079    for(int i = 0; i < filterValues.length; i++) {
2080      arrayAsList.add(
2081        filterValues[i]
2082      );
2083    }
2084    forAllLastName (
2085      operator,
2086      arrayAsList
2087    );
2088  }
2089
2090  public void thereExistsLastName (
2091    short operator,
2092    String  [] filterValues
2093  ) {
2094    java.util.List   arrayAsList = new java.util.ArrayList  ();
2095    for(int i = 0; i < filterValues.length; i++) {
2096      arrayAsList.add(
2097        filterValues[i]
2098      );
2099    }
2100    thereExistsLastName (
2101      operator,
2102      arrayAsList
2103    );
2104  }
2105
2106  public void orderByLastName (
2107    short order
2108  ) {
2109    refAddValue(
2110      "org:opencrx:kernel:account1:Contact:lastName",
2111      order
2112    );
2113  }
2114      
2115// ----------------------------------------------------------------------------
2116// Filter/ImplAttributeIsNotStruct
2117// ----------------------------------------------------------------------------
2118  public void forAllMiddleName (
2119    short operator,
2120    java.util.Collection   values
2121  ) {
2122    refAddValue(
2123      "org:opencrx:kernel:account1:Contact:middleName",
2124      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2125      operator,
2126      values
2127    );
2128  }
2129
2130  public void thereExistsMiddleName (
2131    short operator,
2132    java.util.Collection   values
2133  ) {
2134    refAddValue(
2135      "org:opencrx:kernel:account1:Contact:middleName",
2136      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2137      operator,
2138      values
2139    );
2140  }
2141
2142  public void forAllMiddleName (
2143    short operator,
2144    String  [] filterValues
2145  ) {
2146    java.util.List   arrayAsList = new java.util.ArrayList  ();
2147    for(int i = 0; i < filterValues.length; i++) {
2148      arrayAsList.add(
2149        filterValues[i]
2150      );
2151    }
2152    forAllMiddleName (
2153      operator,
2154      arrayAsList
2155    );
2156  }
2157
2158  public void thereExistsMiddleName (
2159    short operator,
2160    String  [] filterValues
2161  ) {
2162    java.util.List   arrayAsList = new java.util.ArrayList  ();
2163    for(int i = 0; i < filterValues.length; i++) {
2164      arrayAsList.add(
2165        filterValues[i]
2166      );
2167    }
2168    thereExistsMiddleName (
2169      operator,
2170      arrayAsList
2171    );
2172  }
2173
2174  public void orderByMiddleName (
2175    short order
2176  ) {
2177    refAddValue(
2178      "org:opencrx:kernel:account1:Contact:middleName",
2179      order
2180    );
2181  }
2182      
2183// ----------------------------------------------------------------------------
2184// Filter/ImplAttributeIsNotStruct
2185// ----------------------------------------------------------------------------
2186  public void forAllNickName (
2187    short operator,
2188    java.util.Collection   values
2189  ) {
2190    refAddValue(
2191      "org:opencrx:kernel:account1:Contact:nickName",
2192      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2193      operator,
2194      values
2195    );
2196  }
2197
2198  public void thereExistsNickName (
2199    short operator,
2200    java.util.Collection   values
2201  ) {
2202    refAddValue(
2203      "org:opencrx:kernel:account1:Contact:nickName",
2204      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2205      operator,
2206      values
2207    );
2208  }
2209
2210  public void forAllNickName (
2211    short operator,
2212    String  [] filterValues
2213  ) {
2214    java.util.List   arrayAsList = new java.util.ArrayList  ();
2215    for(int i = 0; i < filterValues.length; i++) {
2216      arrayAsList.add(
2217        filterValues[i]
2218      );
2219    }
2220    forAllNickName (
2221      operator,
2222      arrayAsList
2223    );
2224  }
2225
2226  public void thereExistsNickName (
2227    short operator,
2228    String  [] filterValues
2229  ) {
2230    java.util.List   arrayAsList = new java.util.ArrayList  ();
2231    for(int i = 0; i < filterValues.length; i++) {
2232      arrayAsList.add(
2233        filterValues[i]
2234      );
2235    }
2236    thereExistsNickName (
2237      operator,
2238      arrayAsList
2239    );
2240  }
2241
2242  public void orderByNickName (
2243    short order
2244  ) {
2245    refAddValue(
2246      "org:opencrx:kernel:account1:Contact:nickName",
2247      order
2248    );
2249  }
2250      
2251// ----------------------------------------------------------------------------
2252// Filter/ImplAttributeIsNotStruct
2253// ----------------------------------------------------------------------------
2254  public void forAllNumberOfChildren (
2255    short operator,
2256    java.util.Collection   values
2257  ) {
2258    refAddValue(
2259      "org:opencrx:kernel:account1:Contact:numberOfChildren",
2260      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2261      operator,
2262      values
2263    );
2264  }
2265
2266  public void thereExistsNumberOfChildren (
2267    short operator,
2268    java.util.Collection   values
2269  ) {
2270    refAddValue(
2271      "org:opencrx:kernel:account1:Contact:numberOfChildren",
2272      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2273      operator,
2274      values
2275    );
2276  }
2277
2278  public void forAllNumberOfChildren (
2279    short operator,
2280    short[] filterValues
2281  ) {
2282    java.util.List   arrayAsList = new java.util.ArrayList  ();
2283    for(int i = 0; i < filterValues.length; i++) {
2284      arrayAsList.add(
2285        new Short  (filterValues[i])
2286      );
2287    }
2288    forAllNumberOfChildren (
2289      operator,
2290      arrayAsList
2291    );
2292  }
2293
2294  public void thereExistsNumberOfChildren (
2295    short operator,
2296    short[] filterValues
2297  ) {
2298    java.util.List   arrayAsList = new java.util.ArrayList  ();
2299    for(int i = 0; i < filterValues.length; i++) {
2300      arrayAsList.add(
2301        new Short  (filterValues[i])
2302      );
2303    }
2304    thereExistsNumberOfChildren (
2305      operator,
2306      arrayAsList
2307    );
2308  }
2309
2310  public void orderByNumberOfChildren (
2311    short order
2312  ) {
2313    refAddValue(
2314      "org:opencrx:kernel:account1:Contact:numberOfChildren",
2315      order
2316    );
2317  }
2318      
2319// ----------------------------------------------------------------------------
2320// Filter/ImplAttributeIsNotStruct
2321// ----------------------------------------------------------------------------
2322  public void forAllOrganization (
2323    short operator,
2324    java.util.Collection   values
2325  ) {
2326    refAddValue(
2327      "org:opencrx:kernel:account1:Contact:organization",
2328      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2329      operator,
2330      values
2331    );
2332  }
2333
2334  public void thereExistsOrganization (
2335    short operator,
2336    java.util.Collection   values
2337  ) {
2338    refAddValue(
2339      "org:opencrx:kernel:account1:Contact:organization",
2340      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2341      operator,
2342      values
2343    );
2344  }
2345
2346  public void forAllOrganization (
2347    short operator,
2348    String  [] filterValues
2349  ) {
2350    java.util.List   arrayAsList = new java.util.ArrayList  ();
2351    for(int i = 0; i < filterValues.length; i++) {
2352      arrayAsList.add(
2353        filterValues[i]
2354      );
2355    }
2356    forAllOrganization (
2357      operator,
2358      arrayAsList
2359    );
2360  }
2361
2362  public void thereExistsOrganization (
2363    short operator,
2364    String  [] filterValues
2365  ) {
2366    java.util.List   arrayAsList = new java.util.ArrayList  ();
2367    for(int i = 0; i < filterValues.length; i++) {
2368      arrayAsList.add(
2369        filterValues[i]
2370      );
2371    }
2372    thereExistsOrganization (
2373      operator,
2374      arrayAsList
2375    );
2376  }
2377
2378  public void orderByOrganization (
2379    short order
2380  ) {
2381    refAddValue(
2382      "org:opencrx:kernel:account1:Contact:organization",
2383      order
2384    );
2385  }
2386      
2387// ----------------------------------------------------------------------------
2388// Filter/ImplReference
2389// ----------------------------------------------------------------------------
2390  public void forAllOuMembership (
2391    short operator,
2392    org.opencrx.kernel.account1.cci.OrganizationalUnit[] filterValues
2393  ) {
2394    java.util.List   arrayAsList = new java.util.ArrayList  ();
2395    for(int i = 0; i < filterValues.length; i++) {
2396      arrayAsList.add(
2397        filterValues[i]
2398      );
2399    }
2400    forAllOuMembership (
2401      operator,
2402      arrayAsList
2403    );
2404  }
2405
2406  public void thereExistsOuMembership (
2407    short operator,
2408    org.opencrx.kernel.account1.cci.OrganizationalUnit[] filterValues
2409  ) {
2410    java.util.List   arrayAsList = new java.util.ArrayList  ();
2411    for(int i = 0; i < filterValues.length; i++) {
2412      arrayAsList.add(
2413        filterValues[i]
2414      );
2415    }
2416    thereExistsOuMembership (
2417      operator,
2418      arrayAsList
2419    );
2420  }
2421
2422  public void forAllOuMembership (
2423    short operator,
2424    java.util.Collection   values
2425  ) {
2426    refAddValue(
2427      "org:opencrx:kernel:account1:Contact:ouMembership",
2428      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2429      operator,
2430      values
2431    );
2432  }
2433
2434  public void thereExistsOuMembership (
2435    short operator,
2436    java.util.Collection   values
2437  ) {
2438    refAddValue(
2439      "org:opencrx:kernel:account1:Contact:ouMembership",
2440      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2441      operator,
2442      values
2443    );
2444  }
2445      
2446// ----------------------------------------------------------------------------
2447// Filter/ImplAttributeIsNotStruct
2448// ----------------------------------------------------------------------------
2449  public void forAllPreferredContactMethod (
2450    short operator,
2451    java.util.Collection   values
2452  ) {
2453    refAddValue(
2454      "org:opencrx:kernel:account1:Contact:preferredContactMethod",
2455      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2456      operator,
2457      values
2458    );
2459  }
2460
2461  public void thereExistsPreferredContactMethod (
2462    short operator,
2463    java.util.Collection   values
2464  ) {
2465    refAddValue(
2466      "org:opencrx:kernel:account1:Contact:preferredContactMethod",
2467      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2468      operator,
2469      values
2470    );
2471  }
2472
2473  public void forAllPreferredContactMethod (
2474    short operator,
2475    short[] filterValues
2476  ) {
2477    java.util.List   arrayAsList = new java.util.ArrayList  ();
2478    for(int i = 0; i < filterValues.length; i++) {
2479      arrayAsList.add(
2480        new Short  (filterValues[i])
2481      );
2482    }
2483    forAllPreferredContactMethod (
2484      operator,
2485      arrayAsList
2486    );
2487  }
2488
2489  public void thereExistsPreferredContactMethod (
2490    short operator,
2491    short[] filterValues
2492  ) {
2493    java.util.List   arrayAsList = new java.util.ArrayList  ();
2494    for(int i = 0; i < filterValues.length; i++) {
2495      arrayAsList.add(
2496        new Short  (filterValues[i])
2497      );
2498    }
2499    thereExistsPreferredContactMethod (
2500      operator,
2501      arrayAsList
2502    );
2503  }
2504
2505  public void orderByPreferredContactMethod (
2506    short order
2507  ) {
2508    refAddValue(
2509      "org:opencrx:kernel:account1:Contact:preferredContactMethod",
2510      order
2511    );
2512  }
2513      
2514// ----------------------------------------------------------------------------
2515// Filter/ImplAttributeIsNotStruct
2516// ----------------------------------------------------------------------------
2517  public void forAllPreferredSpokenLanguage (
2518    short operator,
2519    java.util.Collection   values
2520  ) {
2521    refAddValue(
2522      "org:opencrx:kernel:account1:Contact:preferredSpokenLanguage",
2523      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2524      operator,
2525      values
2526    );
2527  }
2528
2529  public void thereExistsPreferredSpokenLanguage (
2530    short operator,
2531    java.util.Collection   values
2532  ) {
2533    refAddValue(
2534      "org:opencrx:kernel:account1:Contact:preferredSpokenLanguage",
2535      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2536      operator,
2537      values
2538    );
2539  }
2540
2541  public void forAllPreferredSpokenLanguage (
2542    short operator,
2543    short[] filterValues
2544  ) {
2545    java.util.List   arrayAsList = new java.util.ArrayList  ();
2546    for(int i = 0; i < filterValues.length; i++) {
2547      arrayAsList.add(
2548        new Short  (filterValues[i])
2549      );
2550    }
2551    forAllPreferredSpokenLanguage (
2552      operator,
2553      arrayAsList
2554    );
2555  }
2556
2557  public void thereExistsPreferredSpokenLanguage (
2558    short operator,
2559    short[] filterValues
2560  ) {
2561    java.util.List   arrayAsList = new java.util.ArrayList  ();
2562    for(int i = 0; i < filterValues.length; i++) {
2563      arrayAsList.add(
2564        new Short  (filterValues[i])
2565      );
2566    }
2567    thereExistsPreferredSpokenLanguage (
2568      operator,
2569      arrayAsList
2570    );
2571  }
2572
2573  public void orderByPreferredSpokenLanguage (
2574    short order
2575  ) {
2576    refAddValue(
2577      "org:opencrx:kernel:account1:Contact:preferredSpokenLanguage",
2578      order
2579    );
2580  }
2581      
2582// ----------------------------------------------------------------------------
2583// Filter/ImplAttributeIsNotStruct
2584// ----------------------------------------------------------------------------
2585  public void forAllPreferredWrittenLanguage (
2586    short operator,
2587    java.util.Collection   values
2588  ) {
2589    refAddValue(
2590      "org:opencrx:kernel:account1:Contact:preferredWrittenLanguage",
2591      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2592      operator,
2593      values
2594    );
2595  }
2596
2597  public void thereExistsPreferredWrittenLanguage (
2598    short operator,
2599    java.util.Collection   values
2600  ) {
2601    refAddValue(
2602      "org:opencrx:kernel:account1:Contact:preferredWrittenLanguage",
2603      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2604      operator,
2605      values
2606    );
2607  }
2608
2609  public void forAllPreferredWrittenLanguage (
2610    short operator,
2611    short[] filterValues
2612  ) {
2613    java.util.List   arrayAsList = new java.util.ArrayList  ();
2614    for(int i = 0; i < filterValues.length; i++) {
2615      arrayAsList.add(
2616        new Short  (filterValues[i])
2617      );
2618    }
2619    forAllPreferredWrittenLanguage (
2620      operator,
2621      arrayAsList
2622    );
2623  }
2624
2625  public void thereExistsPreferredWrittenLanguage (
2626    short operator,
2627    short[] filterValues
2628  ) {
2629    java.util.List   arrayAsList = new java.util.ArrayList  ();
2630    for(int i = 0; i < filterValues.length; i++) {
2631      arrayAsList.add(
2632        new Short  (filterValues[i])
2633      );
2634    }
2635    thereExistsPreferredWrittenLanguage (
2636      operator,
2637      arrayAsList
2638    );
2639  }
2640
2641  public void orderByPreferredWrittenLanguage (
2642    short order
2643  ) {
2644    refAddValue(
2645      "org:opencrx:kernel:account1:Contact:preferredWrittenLanguage",
2646      order
2647    );
2648  }
2649      
2650// ----------------------------------------------------------------------------
2651// Filter/ImplReference
2652// ----------------------------------------------------------------------------
2653  public void forAllReportsTo (
2654    short operator,
2655    org.opencrx.kernel.account1.cci.Contact[] filterValues
2656  ) {
2657    java.util.List   arrayAsList = new java.util.ArrayList  ();
2658    for(int i = 0; i < filterValues.length; i++) {
2659      arrayAsList.add(
2660        filterValues[i]
2661      );
2662    }
2663    forAllReportsTo (
2664      operator,
2665      arrayAsList
2666    );
2667  }
2668
2669  public void thereExistsReportsTo (
2670    short operator,
2671    org.opencrx.kernel.account1.cci.Contact[] filterValues
2672  ) {
2673    java.util.List   arrayAsList = new java.util.ArrayList  ();
2674    for(int i = 0; i < filterValues.length; i++) {
2675      arrayAsList.add(
2676        filterValues[i]
2677      );
2678    }
2679    thereExistsReportsTo (
2680      operator,
2681      arrayAsList
2682    );
2683  }
2684
2685  public void forAllReportsTo (
2686    short operator,
2687    java.util.Collection   values
2688  ) {
2689    refAddValue(
2690      "org:opencrx:kernel:account1:Contact:reportsTo",
2691      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2692      operator,
2693      values
2694    );
2695  }
2696
2697  public void thereExistsReportsTo (
2698    short operator,
2699    java.util.Collection   values
2700  ) {
2701    refAddValue(
2702      "org:opencrx:kernel:account1:Contact:reportsTo",
2703      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2704      operator,
2705      values
2706    );
2707  }
2708      
2709// ----------------------------------------------------------------------------
2710// Filter/ImplAttributeIsNotStruct
2711// ----------------------------------------------------------------------------
2712  public void forAllSalutation (
2713    short operator,
2714    java.util.Collection   values
2715  ) {
2716    refAddValue(
2717      "org:opencrx:kernel:account1:Contact:salutation",
2718      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2719      operator,
2720      values
2721    );
2722  }
2723
2724  public void thereExistsSalutation (
2725    short operator,
2726    java.util.Collection   values
2727  ) {
2728    refAddValue(
2729      "org:opencrx:kernel:account1:Contact:salutation",
2730      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2731      operator,
2732      values
2733    );
2734  }
2735
2736  public void forAllSalutation (
2737    short operator,
2738    String  [] filterValues
2739  ) {
2740    java.util.List   arrayAsList = new java.util.ArrayList  ();
2741    for(int i = 0; i < filterValues.length; i++) {
2742      arrayAsList.add(
2743        filterValues[i]
2744      );
2745    }
2746    forAllSalutation (
2747      operator,
2748      arrayAsList
2749    );
2750  }
2751
2752  public void thereExistsSalutation (
2753    short operator,
2754    String  [] filterValues
2755  ) {
2756    java.util.List   arrayAsList = new java.util.ArrayList  ();
2757    for(int i = 0; i < filterValues.length; i++) {
2758      arrayAsList.add(
2759        filterValues[i]
2760      );
2761    }
2762    thereExistsSalutation (
2763      operator,
2764      arrayAsList
2765    );
2766  }
2767
2768  public void orderBySalutation (
2769    short order
2770  ) {
2771    refAddValue(
2772      "org:opencrx:kernel:account1:Contact:salutation",
2773      order
2774    );
2775  }
2776      
2777// ----------------------------------------------------------------------------
2778// Filter/ImplAttributeIsNotStruct
2779// ----------------------------------------------------------------------------
2780  public void forAllSalutationCode (
2781    short operator,
2782    java.util.Collection   values
2783  ) {
2784    refAddValue(
2785      "org:opencrx:kernel:account1:Contact:salutationCode",
2786      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2787      operator,
2788      values
2789    );
2790  }
2791
2792  public void thereExistsSalutationCode (
2793    short operator,
2794    java.util.Collection   values
2795  ) {
2796    refAddValue(
2797      "org:opencrx:kernel:account1:Contact:salutationCode",
2798      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2799      operator,
2800      values
2801    );
2802  }
2803
2804  public void forAllSalutationCode (
2805    short operator,
2806    short[] filterValues
2807  ) {
2808    java.util.List   arrayAsList = new java.util.ArrayList  ();
2809    for(int i = 0; i < filterValues.length; i++) {
2810      arrayAsList.add(
2811        new Short  (filterValues[i])
2812      );
2813    }
2814    forAllSalutationCode (
2815      operator,
2816      arrayAsList
2817    );
2818  }
2819
2820  public void thereExistsSalutationCode (
2821    short operator,
2822    short[] filterValues
2823  ) {
2824    java.util.List   arrayAsList = new java.util.ArrayList  ();
2825    for(int i = 0; i < filterValues.length; i++) {
2826      arrayAsList.add(
2827        new Short  (filterValues[i])
2828      );
2829    }
2830    thereExistsSalutationCode (
2831      operator,
2832      arrayAsList
2833    );
2834  }
2835
2836  public void orderBySalutationCode (
2837    short order
2838  ) {
2839    refAddValue(
2840      "org:opencrx:kernel:account1:Contact:salutationCode",
2841      order
2842    );
2843  }
2844      
2845// ----------------------------------------------------------------------------
2846// Filter/ImplAttributeIsNotStruct
2847// ----------------------------------------------------------------------------
2848  public void forAllSuffix (
2849    short operator,
2850    java.util.Collection   values
2851  ) {
2852    refAddValue(
2853      "org:opencrx:kernel:account1:Contact:suffix",
2854      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2855      operator,
2856      values
2857    );
2858  }
2859
2860  public void thereExistsSuffix (
2861    short operator,
2862    java.util.Collection   values
2863  ) {
2864    refAddValue(
2865      "org:opencrx:kernel:account1:Contact:suffix",
2866      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2867      operator,
2868      values
2869    );
2870  }
2871
2872  public void forAllSuffix (
2873    short operator,
2874    String  [] filterValues
2875  ) {
2876    java.util.List   arrayAsList = new java.util.ArrayList  ();
2877    for(int i = 0; i < filterValues.length; i++) {
2878      arrayAsList.add(
2879        filterValues[i]
2880      );
2881    }
2882    forAllSuffix (
2883      operator,
2884      arrayAsList
2885    );
2886  }
2887
2888  public void thereExistsSuffix (
2889    short operator,
2890    String  [] filterValues
2891  ) {
2892    java.util.List   arrayAsList = new java.util.ArrayList  ();
2893    for(int i = 0; i < filterValues.length; i++) {
2894      arrayAsList.add(
2895        filterValues[i]
2896      );
2897    }
2898    thereExistsSuffix (
2899      operator,
2900      arrayAsList
2901    );
2902  }
2903
2904  public void orderBySuffix (
2905    short order
2906  ) {
2907    refAddValue(
2908      "org:opencrx:kernel:account1:Contact:suffix",
2909      order
2910    );
2911  }
2912      
2913// ----------------------------------------------------------------------------
2914// Filter/ImplAttributeIsNotStruct
2915// ----------------------------------------------------------------------------
2916  public void forAllAccessLevelBrowse (
2917    short operator,
2918    java.util.Collection   values
2919  ) {
2920    refAddValue(
2921      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
2922      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2923      operator,
2924      values
2925    );
2926  }
2927
2928  public void thereExistsAccessLevelBrowse (
2929    short operator,
2930    java.util.Collection   values
2931  ) {
2932    refAddValue(
2933      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
2934      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2935      operator,
2936      values
2937    );
2938  }
2939
2940  public void forAllAccessLevelBrowse (
2941    short operator,
2942    short[] filterValues
2943  ) {
2944    java.util.List   arrayAsList = new java.util.ArrayList  ();
2945    for(int i = 0; i < filterValues.length; i++) {
2946      arrayAsList.add(
2947        new Short  (filterValues[i])
2948      );
2949    }
2950    forAllAccessLevelBrowse (
2951      operator,
2952      arrayAsList
2953    );
2954  }
2955
2956  public void thereExistsAccessLevelBrowse (
2957    short operator,
2958    short[] filterValues
2959  ) {
2960    java.util.List   arrayAsList = new java.util.ArrayList  ();
2961    for(int i = 0; i < filterValues.length; i++) {
2962      arrayAsList.add(
2963        new Short  (filterValues[i])
2964      );
2965    }
2966    thereExistsAccessLevelBrowse (
2967      operator,
2968      arrayAsList
2969    );
2970  }
2971
2972  public void orderByAccessLevelBrowse (
2973    short order
2974  ) {
2975    refAddValue(
2976      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
2977      order
2978    );
2979  }
2980      
2981// ----------------------------------------------------------------------------
2982// Filter/ImplAttributeIsNotStruct
2983// ----------------------------------------------------------------------------
2984  public void forAllAccessLevelDelete (
2985    short operator,
2986    java.util.Collection   values
2987  ) {
2988    refAddValue(
2989      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
2990      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2991      operator,
2992      values
2993    );
2994  }
2995
2996  public void thereExistsAccessLevelDelete (
2997    short operator,
2998    java.util.Collection   values
2999  ) {
3000    refAddValue(
3001      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
3002      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3003      operator,
3004      values
3005    );
3006  }
3007
3008  public void forAllAccessLevelDelete (
3009    short operator,
3010    short[] filterValues
3011  ) {
3012    java.util.List   arrayAsList = new java.util.ArrayList  ();
3013    for(int i = 0; i < filterValues.length; i++) {
3014      arrayAsList.add(
3015        new Short  (filterValues[i])
3016      );
3017    }
3018    forAllAccessLevelDelete (
3019      operator,
3020      arrayAsList
3021    );
3022  }
3023
3024  public void thereExistsAccessLevelDelete (
3025    short operator,
3026    short[] filterValues
3027  ) {
3028    java.util.List   arrayAsList = new java.util.ArrayList  ();
3029    for(int i = 0; i < filterValues.length; i++) {
3030      arrayAsList.add(
3031        new Short  (filterValues[i])
3032      );
3033    }
3034    thereExistsAccessLevelDelete (
3035      operator,
3036      arrayAsList
3037    );
3038  }
3039
3040  public void orderByAccessLevelDelete (
3041    short order
3042  ) {
3043    refAddValue(
3044      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
3045      order
3046    );
3047  }
3048      
3049// ----------------------------------------------------------------------------
3050// Filter/ImplAttributeIsNotStruct
3051// ----------------------------------------------------------------------------
3052  public void forAllAccessLevelUpdate (
3053    short operator,
3054    java.util.Collection   values
3055  ) {
3056    refAddValue(
3057      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
3058      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3059      operator,
3060      values
3061    );
3062  }
3063
3064  public void thereExistsAccessLevelUpdate (
3065    short operator,
3066    java.util.Collection   values
3067  ) {
3068    refAddValue(
3069      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
3070      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3071      operator,
3072      values
3073    );
3074  }
3075
3076  public void forAllAccessLevelUpdate (
3077    short operator,
3078    short[] filterValues
3079  ) {
3080    java.util.List   arrayAsList = new java.util.ArrayList  ();
3081    for(int i = 0; i < filterValues.length; i++) {
3082      arrayAsList.add(
3083        new Short  (filterValues[i])
3084      );
3085    }
3086    forAllAccessLevelUpdate (
3087      operator,
3088      arrayAsList
3089    );
3090  }
3091
3092  public void thereExistsAccessLevelUpdate (
3093    short operator,
3094    short[] filterValues
3095  ) {
3096    java.util.List   arrayAsList = new java.util.ArrayList  ();
3097    for(int i = 0; i < filterValues.length; i++) {
3098      arrayAsList.add(
3099        new Short  (filterValues[i])
3100      );
3101    }
3102    thereExistsAccessLevelUpdate (
3103      operator,
3104      arrayAsList
3105    );
3106  }
3107
3108  public void orderByAccessLevelUpdate (
3109    short order
3110  ) {
3111    refAddValue(
3112      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
3113      order
3114    );
3115  }
3116      
3117// ----------------------------------------------------------------------------
3118// Filter/ImplAttributeIsNotStruct
3119// ----------------------------------------------------------------------------
3120  public void forAllOwner (
3121    short operator,
3122    java.util.Collection   values
3123  ) {
3124    refAddValue(
3125      "org:opencrx:kernel:base:SecureObject:owner",
3126      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3127      operator,
3128      values
3129    );
3130  }
3131
3132  public void thereExistsOwner (
3133    short operator,
3134    java.util.Collection   values
3135  ) {
3136    refAddValue(
3137      "org:opencrx:kernel:base:SecureObject:owner",
3138      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3139      operator,
3140      values
3141    );
3142  }
3143
3144  public void forAllOwner (
3145    short operator,
3146    String  [] filterValues
3147  ) {
3148    java.util.List   arrayAsList = new java.util.ArrayList  ();
3149    for(int i = 0; i < filterValues.length; i++) {
3150      arrayAsList.add(
3151        filterValues[i]
3152      );
3153    }
3154    forAllOwner (
3155      operator,
3156      arrayAsList
3157    );
3158  }
3159
3160  public void thereExistsOwner (
3161    short operator,
3162    String  [] filterValues
3163  ) {
3164    java.util.List   arrayAsList = new java.util.ArrayList  ();
3165    for(int i = 0; i < filterValues.length; i++) {
3166      arrayAsList.add(
3167        filterValues[i]
3168      );
3169    }
3170    thereExistsOwner (
3171      operator,
3172      arrayAsList
3173    );
3174  }
3175
3176  public void orderByOwner (
3177    short order
3178  ) {
3179    refAddValue(
3180      "org:opencrx:kernel:base:SecureObject:owner",
3181      order
3182    );
3183  }
3184      
3185// ----------------------------------------------------------------------------
3186// Filter/ImplReference
3187// ----------------------------------------------------------------------------
3188  public void forAllOwningGroup (
3189    short operator,
3190    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
3191  ) {
3192    java.util.List   arrayAsList = new java.util.ArrayList  ();
3193    for(int i = 0; i < filterValues.length; i++) {
3194      arrayAsList.add(
3195        filterValues[i]
3196      );
3197    }
3198    forAllOwningGroup (
3199      operator,
3200      arrayAsList
3201    );
3202  }
3203
3204  public void thereExistsOwningGroup (
3205    short operator,
3206    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
3207  ) {
3208    java.util.List   arrayAsList = new java.util.ArrayList  ();
3209    for(int i = 0; i < filterValues.length; i++) {
3210      arrayAsList.add(
3211        filterValues[i]
3212      );
3213    }
3214    thereExistsOwningGroup (
3215      operator,
3216      arrayAsList
3217    );
3218  }
3219
3220  public void forAllOwningGroup (
3221    short operator,
3222    java.util.Collection   values
3223  ) {
3224    refAddValue(
3225      "org:opencrx:kernel:base:SecureObject:owningGroup",
3226      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3227      operator,
3228      values
3229    );
3230  }
3231
3232  public void thereExistsOwningGroup (
3233    short operator,
3234    java.util.Collection   values
3235  ) {
3236    refAddValue(
3237      "org:opencrx:kernel:base:SecureObject:owningGroup",
3238      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3239      operator,
3240      values
3241    );
3242  }
3243      
3244// ----------------------------------------------------------------------------
3245// Filter/ImplReference
3246// ----------------------------------------------------------------------------
3247  public void forAllOwningUser (
3248    short operator,
3249    org.opencrx.security.realm1.cci.User[] filterValues
3250  ) {
3251    java.util.List   arrayAsList = new java.util.ArrayList  ();
3252    for(int i = 0; i < filterValues.length; i++) {
3253      arrayAsList.add(
3254        filterValues[i]
3255      );
3256    }
3257    forAllOwningUser (
3258      operator,
3259      arrayAsList
3260    );
3261  }
3262
3263  public void thereExistsOwningUser (
3264    short operator,
3265    org.opencrx.security.realm1.cci.User[] filterValues
3266  ) {
3267    java.util.List   arrayAsList = new java.util.ArrayList  ();
3268    for(int i = 0; i < filterValues.length; i++) {
3269      arrayAsList.add(
3270        filterValues[i]
3271      );
3272    }
3273    thereExistsOwningUser (
3274      operator,
3275      arrayAsList
3276    );
3277  }
3278
3279  public void forAllOwningUser (
3280    short operator,
3281    java.util.Collection   values
3282  ) {
3283    refAddValue(
3284      "org:opencrx:kernel:base:SecureObject:owningUser",
3285      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3286      operator,
3287      values
3288    );
3289  }
3290
3291  public void thereExistsOwningUser (
3292    short operator,
3293    java.util.Collection   values
3294  ) {
3295    refAddValue(
3296      "org:opencrx:kernel:base:SecureObject:owningUser",
3297      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3298      operator,
3299      values
3300    );
3301  }
3302      
3303// ----------------------------------------------------------------------------
3304// Filter/ImplAttributeIsNotStruct
3305// ----------------------------------------------------------------------------
3306  public void forAllCategory (
3307    short operator,
3308    java.util.Collection   values
3309  ) {
3310    refAddValue(
3311      "org:opencrx:kernel:generic:CrxObject:category",
3312      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3313      operator,
3314      values
3315    );
3316  }
3317
3318  public void thereExistsCategory (
3319    short operator,
3320    java.util.Collection   values
3321  ) {
3322    refAddValue(
3323      "org:opencrx:kernel:generic:CrxObject:category",
3324      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3325      operator,
3326      values
3327    );
3328  }
3329
3330  public void forAllCategory (
3331    short operator,
3332    String  [] filterValues
3333  ) {
3334    java.util.List   arrayAsList = new java.util.ArrayList  ();
3335    for(int i = 0; i < filterValues.length; i++) {
3336      arrayAsList.add(
3337        filterValues[i]
3338      );
3339    }
3340    forAllCategory (
3341      operator,
3342      arrayAsList
3343    );
3344  }
3345
3346  public void thereExistsCategory (
3347    short operator,
3348    String  [] filterValues
3349  ) {
3350    java.util.List   arrayAsList = new java.util.ArrayList  ();
3351    for(int i = 0; i < filterValues.length; i++) {
3352      arrayAsList.add(
3353        filterValues[i]
3354      );
3355    }
3356    thereExistsCategory (
3357      operator,
3358      arrayAsList
3359    );
3360  }
3361
3362  public void orderByCategory (
3363    short order
3364  ) {
3365    refAddValue(
3366      "org:opencrx:kernel:generic:CrxObject:category",
3367      order
3368    );
3369  }
3370      
3371// ----------------------------------------------------------------------------
3372// Filter/ImplAttributeIsNotStruct
3373// ----------------------------------------------------------------------------
3374  public void forAllDisabled (
3375    short operator,
3376    java.util.Collection   values
3377  ) {
3378    refAddValue(
3379      "org:opencrx:kernel:generic:CrxObject:disabled",
3380      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3381      operator,
3382      values
3383    );
3384  }
3385
3386  public void thereExistsDisabled (
3387    short operator,
3388    java.util.Collection   values
3389  ) {
3390    refAddValue(
3391      "org:opencrx:kernel:generic:CrxObject:disabled",
3392      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3393      operator,
3394      values
3395    );
3396  }
3397
3398  public void forAllDisabled (
3399    short operator,
3400    boolean[] filterValues
3401  ) {
3402    java.util.List   arrayAsList = new java.util.ArrayList  ();
3403    for(int i = 0; i < filterValues.length; i++) {
3404      arrayAsList.add(
3405        new Boolean  (filterValues[i])
3406      );
3407    }
3408    forAllDisabled (
3409      operator,
3410      arrayAsList
3411    );
3412  }
3413
3414  public void thereExistsDisabled (
3415    short operator,
3416    boolean[] filterValues
3417  ) {
3418    java.util.List   arrayAsList = new java.util.ArrayList  ();
3419    for(int i = 0; i < filterValues.length; i++) {
3420      arrayAsList.add(
3421        new Boolean  (filterValues[i])
3422      );
3423    }
3424    thereExistsDisabled (
3425      operator,
3426      arrayAsList
3427    );
3428  }
3429
3430  public void orderByDisabled (
3431    short order
3432  ) {
3433    refAddValue(
3434      "org:opencrx:kernel:generic:CrxObject:disabled",
3435      order
3436    );
3437  }
3438      
3439// ----------------------------------------------------------------------------
3440// Filter/ImplAttributeIsNotStruct
3441// ----------------------------------------------------------------------------
3442  public void forAllDisabledReason (
3443    short operator,
3444    java.util.Collection   values
3445  ) {
3446    refAddValue(
3447      "org:opencrx:kernel:generic:CrxObject:disabledReason",
3448      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3449      operator,
3450      values
3451    );
3452  }
3453
3454  public void thereExistsDisabledReason (
3455    short operator,
3456    java.util.Collection   values
3457  ) {
3458    refAddValue(
3459      "org:opencrx:kernel:generic:CrxObject:disabledReason",
3460      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3461      operator,
3462      values
3463    );
3464  }
3465
3466  public void forAllDisabledReason (
3467    short operator,
3468    String  [] filterValues
3469  ) {
3470    java.util.List   arrayAsList = new java.util.ArrayList  ();
3471    for(int i = 0; i < filterValues.length; i++) {
3472      arrayAsList.add(
3473        filterValues[i]
3474      );
3475    }
3476    forAllDisabledReason (
3477      operator,
3478      arrayAsList
3479    );
3480  }
3481
3482  public void thereExistsDisabledReason (
3483    short operator,
3484    String  [] filterValues
3485  ) {
3486    java.util.List   arrayAsList = new java.util.ArrayList  ();
3487    for(int i = 0; i < filterValues.length; i++) {
3488      arrayAsList.add(
3489        filterValues[i]
3490      );
3491    }
3492    thereExistsDisabledReason (
3493      operator,
3494      arrayAsList
3495    );
3496  }
3497
3498  public void orderByDisabledReason (
3499    short order
3500  ) {
3501    refAddValue(
3502      "org:opencrx:kernel:generic:CrxObject:disabledReason",
3503      order
3504    );
3505  }
3506      
3507// ----------------------------------------------------------------------------
3508// Filter/ImplAttributeIsNotStruct
3509// ----------------------------------------------------------------------------
3510  public void forAllExternalLink (
3511    short operator,
3512    java.util.Collection   values
3513  ) {
3514    refAddValue(
3515      "org:opencrx:kernel:generic:CrxObject:externalLink",
3516      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3517      operator,
3518      values
3519    );
3520  }
3521
3522  public void thereExistsExternalLink (
3523    short operator,
3524    java.util.Collection   values
3525  ) {
3526    refAddValue(
3527      "org:opencrx:kernel:generic:CrxObject:externalLink",
3528      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3529      operator,
3530      values
3531    );
3532  }
3533
3534  public void forAllExternalLink (
3535    short operator,
3536    String  [] filterValues
3537  ) {
3538    java.util.List   arrayAsList = new java.util.ArrayList  ();
3539    for(int i = 0; i < filterValues.length; i++) {
3540      arrayAsList.add(
3541        filterValues[i]
3542      );
3543    }
3544    forAllExternalLink (
3545      operator,
3546      arrayAsList
3547    );
3548  }
3549
3550  public void thereExistsExternalLink (
3551    short operator,
3552    String  [] filterValues
3553  ) {
3554    java.util.List   arrayAsList = new java.util.ArrayList  ();
3555    for(int i = 0; i < filterValues.length; i++) {
3556      arrayAsList.add(
3557        filterValues[i]
3558      );
3559    }
3560    thereExistsExternalLink (
3561      operator,
3562      arrayAsList
3563    );
3564  }
3565
3566  public void orderByExternalLink (
3567    short order
3568  ) {
3569    refAddValue(
3570      "org:opencrx:kernel:generic:CrxObject:externalLink",
3571      order
3572    );
3573  }
3574      
3575// ----------------------------------------------------------------------------
3576// Filter/ImplAttributeIsNotStruct
3577// ----------------------------------------------------------------------------
3578  public void forAllUserBoolean0 (
3579    short operator,
3580    java.util.Collection   values
3581  ) {
3582    refAddValue(
3583      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
3584      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3585      operator,
3586      values
3587    );
3588  }
3589
3590  public void thereExistsUserBoolean0 (
3591    short operator,
3592    java.util.Collection   values
3593  ) {
3594    refAddValue(
3595      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
3596      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3597      operator,
3598      values
3599    );
3600  }
3601
3602  public void forAllUserBoolean0 (
3603    short operator,
3604    boolean[] filterValues
3605  ) {
3606    java.util.List   arrayAsList = new java.util.ArrayList  ();
3607    for(int i = 0; i < filterValues.length; i++) {
3608      arrayAsList.add(
3609        new Boolean  (filterValues[i])
3610      );
3611    }
3612    forAllUserBoolean0 (
3613      operator,
3614      arrayAsList
3615    );
3616  }
3617
3618  public void thereExistsUserBoolean0 (
3619    short operator,
3620    boolean[] filterValues
3621  ) {
3622    java.util.List   arrayAsList = new java.util.ArrayList  ();
3623    for(int i = 0; i < filterValues.length; i++) {
3624      arrayAsList.add(
3625        new Boolean  (filterValues[i])
3626      );
3627    }
3628    thereExistsUserBoolean0 (
3629      operator,
3630      arrayAsList
3631    );
3632  }
3633
3634  public void orderByUserBoolean0 (
3635    short order
3636  ) {
3637    refAddValue(
3638      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
3639      order
3640    );
3641  }
3642      
3643// ----------------------------------------------------------------------------
3644// Filter/ImplAttributeIsNotStruct
3645// ----------------------------------------------------------------------------
3646  public void forAllUserBoolean1 (
3647    short operator,
3648    java.util.Collection   values
3649  ) {
3650    refAddValue(
3651      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
3652      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3653      operator,
3654      values
3655    );
3656  }
3657
3658  public void thereExistsUserBoolean1 (
3659    short operator,
3660    java.util.Collection   values
3661  ) {
3662    refAddValue(
3663      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
3664      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3665      operator,
3666      values
3667    );
3668  }
3669
3670  public void forAllUserBoolean1 (
3671    short operator,
3672    boolean[] filterValues
3673  ) {
3674    java.util.List   arrayAsList = new java.util.ArrayList  ();
3675    for(int i = 0; i < filterValues.length; i++) {
3676      arrayAsList.add(
3677        new Boolean  (filterValues[i])
3678      );
3679    }
3680    forAllUserBoolean1 (
3681      operator,
3682      arrayAsList
3683    );
3684  }
3685
3686  public void thereExistsUserBoolean1 (
3687    short operator,
3688    boolean[] filterValues
3689  ) {
3690    java.util.List   arrayAsList = new java.util.ArrayList  ();
3691    for(int i = 0; i < filterValues.length; i++) {
3692      arrayAsList.add(
3693        new Boolean  (filterValues[i])
3694      );
3695    }
3696    thereExistsUserBoolean1 (
3697      operator,
3698      arrayAsList
3699    );
3700  }
3701
3702  public void orderByUserBoolean1 (
3703    short order
3704  ) {
3705    refAddValue(
3706      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
3707      order
3708    );
3709  }
3710      
3711// ----------------------------------------------------------------------------
3712// Filter/ImplAttributeIsNotStruct
3713// ----------------------------------------------------------------------------
3714  public void forAllUserBoolean2 (
3715    short operator,
3716    java.util.Collection   values
3717  ) {
3718    refAddValue(
3719      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
3720      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3721      operator,
3722      values
3723    );
3724  }
3725
3726  public void thereExistsUserBoolean2 (
3727    short operator,
3728    java.util.Collection   values
3729  ) {
3730    refAddValue(
3731      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
3732      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3733      operator,
3734      values
3735    );
3736  }
3737
3738  public void forAllUserBoolean2 (
3739    short operator,
3740    boolean[] filterValues
3741  ) {
3742    java.util.List   arrayAsList = new java.util.ArrayList  ();
3743    for(int i = 0; i < filterValues.length; i++) {
3744      arrayAsList.add(
3745        new Boolean  (filterValues[i])
3746      );
3747    }
3748    forAllUserBoolean2 (
3749      operator,
3750      arrayAsList
3751    );
3752  }
3753
3754  public void thereExistsUserBoolean2 (
3755    short operator,
3756    boolean[] filterValues
3757  ) {
3758    java.util.List   arrayAsList = new java.util.ArrayList  ();
3759    for(int i = 0; i < filterValues.length; i++) {
3760      arrayAsList.add(
3761        new Boolean  (filterValues[i])
3762      );
3763    }
3764    thereExistsUserBoolean2 (
3765      operator,
3766      arrayAsList
3767    );
3768  }
3769
3770  public void orderByUserBoolean2 (
3771    short order
3772  ) {
3773    refAddValue(
3774      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
3775      order
3776    );
3777  }
3778      
3779// ----------------------------------------------------------------------------
3780// Filter/ImplAttributeIsNotStruct
3781// ----------------------------------------------------------------------------
3782  public void forAllUserBoolean3 (
3783    short operator,
3784    java.util.Collection   values
3785  ) {
3786    refAddValue(
3787      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
3788      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3789      operator,
3790      values
3791    );
3792  }
3793
3794  public void thereExistsUserBoolean3 (
3795    short operator,
3796    java.util.Collection   values
3797  ) {
3798    refAddValue(
3799      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
3800      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3801      operator,
3802      values
3803    );
3804  }
3805
3806  public void forAllUserBoolean3 (
3807    short operator,
3808    boolean[] filterValues
3809  ) {
3810    java.util.List   arrayAsList = new java.util.ArrayList  ();
3811    for(int i = 0; i < filterValues.length; i++) {
3812      arrayAsList.add(
3813        new Boolean  (filterValues[i])
3814      );
3815    }
3816    forAllUserBoolean3 (
3817      operator,
3818      arrayAsList
3819    );
3820  }
3821
3822  public void thereExistsUserBoolean3 (
3823    short operator,
3824    boolean[] filterValues
3825  ) {
3826    java.util.List   arrayAsList = new java.util.ArrayList  ();
3827    for(int i = 0; i < filterValues.length; i++) {
3828      arrayAsList.add(
3829        new Boolean  (filterValues[i])
3830      );
3831    }
3832    thereExistsUserBoolean3 (
3833      operator,
3834      arrayAsList
3835    );
3836  }
3837
3838  public void orderByUserBoolean3 (
3839    short order
3840  ) {
3841    refAddValue(
3842      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
3843      order
3844    );
3845  }
3846      
3847// ----------------------------------------------------------------------------
3848// Filter/ImplAttributeIsNotStruct
3849// ----------------------------------------------------------------------------
3850  public void forAllUserBoolean4 (
3851    short operator,
3852    java.util.Collection   values
3853  ) {
3854    refAddValue(
3855      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
3856      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3857      operator,
3858      values
3859    );
3860  }
3861
3862  public void thereExistsUserBoolean4 (
3863    short operator,
3864    java.util.Collection   values
3865  ) {
3866    refAddValue(
3867      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
3868      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3869      operator,
3870      values
3871    );
3872  }
3873
3874  public void forAllUserBoolean4 (
3875    short operator,
3876    boolean[] filterValues
3877  ) {
3878    java.util.List   arrayAsList = new java.util.ArrayList  ();
3879    for(int i = 0; i < filterValues.length; i++) {
3880      arrayAsList.add(
3881        new Boolean  (filterValues[i])
3882      );
3883    }
3884    forAllUserBoolean4 (
3885      operator,
3886      arrayAsList
3887    );
3888  }
3889
3890  public void thereExistsUserBoolean4 (
3891    short operator,
3892    boolean[] filterValues
3893  ) {
3894    java.util.List   arrayAsList = new java.util.ArrayList  ();
3895    for(int i = 0; i < filterValues.length; i++) {
3896      arrayAsList.add(
3897        new Boolean  (filterValues[i])
3898      );
3899    }
3900    thereExistsUserBoolean4 (
3901      operator,
3902      arrayAsList
3903    );
3904  }
3905
3906  public void orderByUserBoolean4 (
3907    short order
3908  ) {
3909    refAddValue(
3910      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
3911      order
3912    );
3913  }
3914      
3915// ----------------------------------------------------------------------------
3916// Filter/ImplAttributeIsNotStruct
3917// ----------------------------------------------------------------------------
3918  public void forAllUserCode0 (
3919    short operator,
3920    java.util.Collection   values
3921  ) {
3922    refAddValue(
3923      "org:opencrx:kernel:generic:CrxObject:userCode0",
3924      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3925      operator,
3926      values
3927    );
3928  }
3929
3930  public void thereExistsUserCode0 (
3931    short operator,
3932    java.util.Collection   values
3933  ) {
3934    refAddValue(
3935      "org:opencrx:kernel:generic:CrxObject:userCode0",
3936      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3937      operator,
3938      values
3939    );
3940  }
3941
3942  public void forAllUserCode0 (
3943    short operator,
3944    short[] filterValues
3945  ) {
3946    java.util.List   arrayAsList = new java.util.ArrayList  ();
3947    for(int i = 0; i < filterValues.length; i++) {
3948      arrayAsList.add(
3949        new Short  (filterValues[i])
3950      );
3951    }
3952    forAllUserCode0 (
3953      operator,
3954      arrayAsList
3955    );
3956  }
3957
3958  public void thereExistsUserCode0 (
3959    short operator,
3960    short[] filterValues
3961  ) {
3962    java.util.List   arrayAsList = new java.util.ArrayList  ();
3963    for(int i = 0; i < filterValues.length; i++) {
3964      arrayAsList.add(
3965        new Short  (filterValues[i])
3966      );
3967    }
3968    thereExistsUserCode0 (
3969      operator,
3970      arrayAsList
3971    );
3972  }
3973
3974  public void orderByUserCode0 (
3975    short order
3976  ) {
3977    refAddValue(
3978      "org:opencrx:kernel:generic:CrxObject:userCode0",
3979      order
3980    );
3981  }
3982      
3983// ----------------------------------------------------------------------------
3984// Filter/ImplAttributeIsNotStruct
3985// ----------------------------------------------------------------------------
3986  public void forAllUserCode1 (
3987    short operator,
3988    java.util.Collection   values
3989  ) {
3990    refAddValue(
3991      "org:opencrx:kernel:generic:CrxObject:userCode1",
3992      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3993      operator,
3994      values
3995    );
3996  }
3997
3998  public void thereExistsUserCode1 (
3999    short operator,
4000    java.util.Collection   values
4001  ) {
4002    refAddValue(
4003      "org:opencrx:kernel:generic:CrxObject:userCode1",
4004      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4005      operator,
4006      values
4007    );
4008  }
4009
4010  public void forAllUserCode1 (
4011    short operator,
4012    short[] filterValues
4013  ) {
4014    java.util.List   arrayAsList = new java.util.ArrayList  ();
4015    for(int i = 0; i < filterValues.length; i++) {
4016      arrayAsList.add(
4017        new Short  (filterValues[i])
4018      );
4019    }
4020    forAllUserCode1 (
4021      operator,
4022      arrayAsList
4023    );
4024  }
4025
4026  public void thereExistsUserCode1 (
4027    short operator,
4028    short[] filterValues
4029  ) {
4030    java.util.List   arrayAsList = new java.util.ArrayList  ();
4031    for(int i = 0; i < filterValues.length; i++) {
4032      arrayAsList.add(
4033        new Short  (filterValues[i])
4034      );
4035    }
4036    thereExistsUserCode1 (
4037      operator,
4038      arrayAsList
4039    );
4040  }
4041
4042  public void orderByUserCode1 (
4043    short order
4044  ) {
4045    refAddValue(
4046      "org:opencrx:kernel:generic:CrxObject:userCode1",
4047      order
4048    );
4049  }
4050      
4051// ----------------------------------------------------------------------------
4052// Filter/ImplAttributeIsNotStruct
4053// ----------------------------------------------------------------------------
4054  public void forAllUserCode2 (
4055    short operator,
4056    java.util.Collection   values
4057  ) {
4058    refAddValue(
4059      "org:opencrx:kernel:generic:CrxObject:userCode2",
4060      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4061      operator,
4062      values
4063    );
4064  }
4065
4066  public void thereExistsUserCode2 (
4067    short operator,
4068    java.util.Collection   values
4069  ) {
4070    refAddValue(
4071      "org:opencrx:kernel:generic:CrxObject:userCode2",
4072      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4073      operator,
4074      values
4075    );
4076  }
4077
4078  public void forAllUserCode2 (
4079    short operator,
4080    short[] filterValues
4081  ) {
4082    java.util.List   arrayAsList = new java.util.ArrayList  ();
4083    for(int i = 0; i < filterValues.length; i++) {
4084      arrayAsList.add(
4085        new Short  (filterValues[i])
4086      );
4087    }
4088    forAllUserCode2 (
4089      operator,
4090      arrayAsList
4091    );
4092  }
4093
4094  public void thereExistsUserCode2 (
4095    short operator,
4096    short[] filterValues
4097  ) {
4098    java.util.List   arrayAsList = new java.util.ArrayList  ();
4099    for(int i = 0; i < filterValues.length; i++) {
4100      arrayAsList.add(
4101        new Short  (filterValues[i])
4102      );
4103    }
4104    thereExistsUserCode2 (
4105      operator,
4106      arrayAsList
4107    );
4108  }
4109
4110  public void orderByUserCode2 (
4111    short order
4112  ) {
4113    refAddValue(
4114      "org:opencrx:kernel:generic:CrxObject:userCode2",
4115      order
4116    );
4117  }
4118      
4119// ----------------------------------------------------------------------------
4120// Filter/ImplAttributeIsNotStruct
4121// ----------------------------------------------------------------------------
4122  public void forAllUserCode3 (
4123    short operator,
4124    java.util.Collection   values
4125  ) {
4126    refAddValue(
4127      "org:opencrx:kernel:generic:CrxObject:userCode3",
4128      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4129      operator,
4130      values
4131    );
4132  }
4133
4134  public void thereExistsUserCode3 (
4135    short operator,
4136    java.util.Collection   values
4137  ) {
4138    refAddValue(
4139      "org:opencrx:kernel:generic:CrxObject:userCode3",
4140      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4141      operator,
4142      values
4143    );
4144  }
4145
4146  public void forAllUserCode3 (
4147    short operator,
4148    short[] filterValues
4149  ) {
4150    java.util.List   arrayAsList = new java.util.ArrayList  ();
4151    for(int i = 0; i < filterValues.length; i++) {
4152      arrayAsList.add(
4153        new Short  (filterValues[i])
4154      );
4155    }
4156    forAllUserCode3 (
4157      operator,
4158      arrayAsList
4159    );
4160  }
4161
4162  public void thereExistsUserCode3 (
4163    short operator,
4164    short[] filterValues
4165  ) {
4166    java.util.List   arrayAsList = new java.util.ArrayList  ();
4167    for(int i = 0; i < filterValues.length; i++) {
4168      arrayAsList.add(
4169        new Short  (filterValues[i])
4170      );
4171    }
4172    thereExistsUserCode3 (
4173      operator,
4174      arrayAsList
4175    );
4176  }
4177
4178  public void orderByUserCode3 (
4179    short order
4180  ) {
4181    refAddValue(
4182      "org:opencrx:kernel:generic:CrxObject:userCode3",
4183      order
4184    );
4185  }
4186      
4187// ----------------------------------------------------------------------------
4188// Filter/ImplAttributeIsNotStruct
4189// ----------------------------------------------------------------------------
4190  public void forAllUserCode4 (
4191    short operator,
4192    java.util.Collection   values
4193  ) {
4194    refAddValue(
4195      "org:opencrx:kernel:generic:CrxObject:userCode4",
4196      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4197      operator,
4198      values
4199    );
4200  }
4201
4202  public void thereExistsUserCode4 (
4203    short operator,
4204    java.util.Collection   values
4205  ) {
4206    refAddValue(
4207      "org:opencrx:kernel:generic:CrxObject:userCode4",
4208      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4209      operator,
4210      values
4211    );
4212  }
4213
4214  public void forAllUserCode4 (
4215    short operator,
4216    short[] filterValues
4217  ) {
4218    java.util.List   arrayAsList = new java.util.ArrayList  ();
4219    for(int i = 0; i < filterValues.length; i++) {
4220      arrayAsList.add(
4221        new Short  (filterValues[i])
4222      );
4223    }
4224    forAllUserCode4 (
4225      operator,
4226      arrayAsList
4227    );
4228  }
4229
4230  public void thereExistsUserCode4 (
4231    short operator,
4232    short[] filterValues
4233  ) {
4234    java.util.List   arrayAsList = new java.util.ArrayList  ();
4235    for(int i = 0; i < filterValues.length; i++) {
4236      arrayAsList.add(
4237        new Short  (filterValues[i])
4238      );
4239    }
4240    thereExistsUserCode4 (
4241      operator,
4242      arrayAsList
4243    );
4244  }
4245
4246  public void orderByUserCode4 (
4247    short order
4248  ) {
4249    refAddValue(
4250      "org:opencrx:kernel:generic:CrxObject:userCode4",
4251      order
4252    );
4253  }
4254      
4255// ----------------------------------------------------------------------------
4256// Filter/ImplAttributeIsNotStruct
4257// ----------------------------------------------------------------------------
4258  public void forAllUserDate0 (
4259    short operator,
4260    java.util.Collection   values
4261  ) {
4262    refAddValue(
4263      "org:opencrx:kernel:generic:CrxObject:userDate0",
4264      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4265      operator,
4266      values
4267    );
4268  }
4269
4270  public void thereExistsUserDate0 (
4271    short operator,
4272    java.util.Collection   values
4273  ) {
4274    refAddValue(
4275      "org:opencrx:kernel:generic:CrxObject:userDate0",
4276      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4277      operator,
4278      values
4279    );
4280  }
4281
4282  public void forAllUserDate0 (
4283    short operator,
4284    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4285  ) {
4286    java.util.List   arrayAsList = new java.util.ArrayList  ();
4287    for(int i = 0; i < filterValues.length; i++) {
4288      arrayAsList.add(
4289        filterValues[i]
4290      );
4291    }
4292    forAllUserDate0 (
4293      operator,
4294      arrayAsList
4295    );
4296  }
4297
4298  public void thereExistsUserDate0 (
4299    short operator,
4300    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4301  ) {
4302    java.util.List   arrayAsList = new java.util.ArrayList  ();
4303    for(int i = 0; i < filterValues.length; i++) {
4304      arrayAsList.add(
4305        filterValues[i]
4306      );
4307    }
4308    thereExistsUserDate0 (
4309      operator,
4310      arrayAsList
4311    );
4312  }
4313
4314  public void orderByUserDate0 (
4315    short order
4316  ) {
4317    refAddValue(
4318      "org:opencrx:kernel:generic:CrxObject:userDate0",
4319      order
4320    );
4321  }
4322      
4323// ----------------------------------------------------------------------------
4324// Filter/ImplAttributeIsNotStruct
4325// ----------------------------------------------------------------------------
4326  public void forAllUserDate1 (
4327    short operator,
4328    java.util.Collection   values
4329  ) {
4330    refAddValue(
4331      "org:opencrx:kernel:generic:CrxObject:userDate1",
4332      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4333      operator,
4334      values
4335    );
4336  }
4337
4338  public void thereExistsUserDate1 (
4339    short operator,
4340    java.util.Collection   values
4341  ) {
4342    refAddValue(
4343      "org:opencrx:kernel:generic:CrxObject:userDate1",
4344      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4345      operator,
4346      values
4347    );
4348  }
4349
4350  public void forAllUserDate1 (
4351    short operator,
4352    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4353  ) {
4354    java.util.List   arrayAsList = new java.util.ArrayList  ();
4355    for(int i = 0; i < filterValues.length; i++) {
4356      arrayAsList.add(
4357        filterValues[i]
4358      );
4359    }
4360    forAllUserDate1 (
4361      operator,
4362      arrayAsList
4363    );
4364  }
4365
4366  public void thereExistsUserDate1 (
4367    short operator,
4368    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4369  ) {
4370    java.util.List   arrayAsList = new java.util.ArrayList  ();
4371    for(int i = 0; i < filterValues.length; i++) {
4372      arrayAsList.add(
4373        filterValues[i]
4374      );
4375    }
4376    thereExistsUserDate1 (
4377      operator,
4378      arrayAsList
4379    );
4380  }
4381
4382  public void orderByUserDate1 (
4383    short order
4384  ) {
4385    refAddValue(
4386      "org:opencrx:kernel:generic:CrxObject:userDate1",
4387      order
4388    );
4389  }
4390      
4391// ----------------------------------------------------------------------------
4392// Filter/ImplAttributeIsNotStruct
4393// ----------------------------------------------------------------------------
4394  public void forAllUserDate2 (
4395    short operator,
4396    java.util.Collection   values
4397  ) {
4398    refAddValue(
4399      "org:opencrx:kernel:generic:CrxObject:userDate2",
4400      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4401      operator,
4402      values
4403    );
4404  }
4405
4406  public void thereExistsUserDate2 (
4407    short operator,
4408    java.util.Collection   values
4409  ) {
4410    refAddValue(
4411      "org:opencrx:kernel:generic:CrxObject:userDate2",
4412      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4413      operator,
4414      values
4415    );
4416  }
4417
4418  public void forAllUserDate2 (
4419    short operator,
4420    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4421  ) {
4422    java.util.List   arrayAsList = new java.util.ArrayList  ();
4423    for(int i = 0; i < filterValues.length; i++) {
4424      arrayAsList.add(
4425        filterValues[i]
4426      );
4427    }
4428    forAllUserDate2 (
4429      operator,
4430      arrayAsList
4431    );
4432  }
4433
4434  public void thereExistsUserDate2 (
4435    short operator,
4436    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4437  ) {
4438    java.util.List   arrayAsList = new java.util.ArrayList  ();
4439    for(int i = 0; i < filterValues.length; i++) {
4440      arrayAsList.add(
4441        filterValues[i]
4442      );
4443    }
4444    thereExistsUserDate2 (
4445      operator,
4446      arrayAsList
4447    );
4448  }
4449
4450  public void orderByUserDate2 (
4451    short order
4452  ) {
4453    refAddValue(
4454      "org:opencrx:kernel:generic:CrxObject:userDate2",
4455      order
4456    );
4457  }
4458      
4459// ----------------------------------------------------------------------------
4460// Filter/ImplAttributeIsNotStruct
4461// ----------------------------------------------------------------------------
4462  public void forAllUserDate3 (
4463    short operator,
4464    java.util.Collection   values
4465  ) {
4466    refAddValue(
4467      "org:opencrx:kernel:generic:CrxObject:userDate3",
4468      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4469      operator,
4470      values
4471    );
4472  }
4473
4474  public void thereExistsUserDate3 (
4475    short operator,
4476    java.util.Collection   values
4477  ) {
4478    refAddValue(
4479      "org:opencrx:kernel:generic:CrxObject:userDate3",
4480      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4481      operator,
4482      values
4483    );
4484  }
4485
4486  public void forAllUserDate3 (
4487    short operator,
4488    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4489  ) {
4490    java.util.List   arrayAsList = new java.util.ArrayList  ();
4491    for(int i = 0; i < filterValues.length; i++) {
4492      arrayAsList.add(
4493        filterValues[i]
4494      );
4495    }
4496    forAllUserDate3 (
4497      operator,
4498      arrayAsList
4499    );
4500  }
4501
4502  public void thereExistsUserDate3 (
4503    short operator,
4504    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4505  ) {
4506    java.util.List   arrayAsList = new java.util.ArrayList  ();
4507    for(int i = 0; i < filterValues.length; i++) {
4508      arrayAsList.add(
4509        filterValues[i]
4510      );
4511    }
4512    thereExistsUserDate3 (
4513      operator,
4514      arrayAsList
4515    );
4516  }
4517
4518  public void orderByUserDate3 (
4519    short order
4520  ) {
4521    refAddValue(
4522      "org:opencrx:kernel:generic:CrxObject:userDate3",
4523      order
4524    );
4525  }
4526      
4527// ----------------------------------------------------------------------------
4528// Filter/ImplAttributeIsNotStruct
4529// ----------------------------------------------------------------------------
4530  public void forAllUserDate4 (
4531    short operator,
4532    java.util.Collection   values
4533  ) {
4534    refAddValue(
4535      "org:opencrx:kernel:generic:CrxObject:userDate4",
4536      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4537      operator,
4538      values
4539    );
4540  }
4541
4542  public void thereExistsUserDate4 (
4543    short operator,
4544    java.util.Collection   values
4545  ) {
4546    refAddValue(
4547      "org:opencrx:kernel:generic:CrxObject:userDate4",
4548      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4549      operator,
4550      values
4551    );
4552  }
4553
4554  public void forAllUserDate4 (
4555    short operator,
4556    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4557  ) {
4558    java.util.List   arrayAsList = new java.util.ArrayList  ();
4559    for(int i = 0; i < filterValues.length; i++) {
4560      arrayAsList.add(
4561        filterValues[i]
4562      );
4563    }
4564    forAllUserDate4 (
4565      operator,
4566      arrayAsList
4567    );
4568  }
4569
4570  public void thereExistsUserDate4 (
4571    short operator,
4572    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
4573  ) {
4574    java.util.List   arrayAsList = new java.util.ArrayList  ();
4575    for(int i = 0; i < filterValues.length; i++) {
4576      arrayAsList.add(
4577        filterValues[i]
4578      );
4579    }
4580    thereExistsUserDate4 (
4581      operator,
4582      arrayAsList
4583    );
4584  }
4585
4586  public void orderByUserDate4 (
4587    short order
4588  ) {
4589    refAddValue(
4590      "org:opencrx:kernel:generic:CrxObject:userDate4",
4591      order
4592    );
4593  }
4594      
4595// ----------------------------------------------------------------------------
4596// Filter/ImplAttributeIsNotStruct
4597// ----------------------------------------------------------------------------
4598  public void forAllUserDateTime0 (
4599    short operator,
4600    java.util.Collection   values
4601  ) {
4602    refAddValue(
4603      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
4604      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4605      operator,
4606      values
4607    );
4608  }
4609
4610  public void thereExistsUserDateTime0 (
4611    short operator,
4612    java.util.Collection   values
4613  ) {
4614    refAddValue(
4615      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
4616      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4617      operator,
4618      values
4619    );
4620  }
4621
4622  public void forAllUserDateTime0 (
4623    short operator,
4624    java.util.Date  [] filterValues
4625  ) {
4626    java.util.List   arrayAsList = new java.util.ArrayList  ();
4627    for(int i = 0; i < filterValues.length; i++) {
4628      arrayAsList.add(
4629        filterValues[i]
4630      );
4631    }
4632    forAllUserDateTime0 (
4633      operator,
4634      arrayAsList
4635    );
4636  }
4637
4638  public void thereExistsUserDateTime0 (
4639    short operator,
4640    java.util.Date  [] filterValues
4641  ) {
4642    java.util.List   arrayAsList = new java.util.ArrayList  ();
4643    for(int i = 0; i < filterValues.length; i++) {
4644      arrayAsList.add(
4645        filterValues[i]
4646      );
4647    }
4648    thereExistsUserDateTime0 (
4649      operator,
4650      arrayAsList
4651    );
4652  }
4653
4654  public void orderByUserDateTime0 (
4655    short order
4656  ) {
4657    refAddValue(
4658      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
4659      order
4660    );
4661  }
4662      
4663// ----------------------------------------------------------------------------
4664// Filter/ImplAttributeIsNotStruct
4665// ----------------------------------------------------------------------------
4666  public void forAllUserDateTime1 (
4667    short operator,
4668    java.util.Collection   values
4669  ) {
4670    refAddValue(
4671      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
4672      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4673      operator,
4674      values
4675    );
4676  }
4677
4678  public void thereExistsUserDateTime1 (
4679    short operator,
4680    java.util.Collection   values
4681  ) {
4682    refAddValue(
4683      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
4684      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4685      operator,
4686      values
4687    );
4688  }
4689
4690  public void forAllUserDateTime1 (
4691    short operator,
4692    java.util.Date  [] filterValues
4693  ) {
4694    java.util.List   arrayAsList = new java.util.ArrayList  ();
4695    for(int i = 0; i < filterValues.length; i++) {
4696      arrayAsList.add(
4697        filterValues[i]
4698      );
4699    }
4700    forAllUserDateTime1 (
4701      operator,
4702      arrayAsList
4703    );
4704  }
4705
4706  public void thereExistsUserDateTime1 (
4707    short operator,
4708    java.util.Date  [] filterValues
4709  ) {
4710    java.util.List   arrayAsList = new java.util.ArrayList  ();
4711    for(int i = 0; i < filterValues.length; i++) {
4712      arrayAsList.add(
4713        filterValues[i]
4714      );
4715    }
4716    thereExistsUserDateTime1 (
4717      operator,
4718      arrayAsList
4719    );
4720  }
4721
4722  public void orderByUserDateTime1 (
4723    short order
4724  ) {
4725    refAddValue(
4726      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
4727      order
4728    );
4729  }
4730      
4731// ----------------------------------------------------------------------------
4732// Filter/ImplAttributeIsNotStruct
4733// ----------------------------------------------------------------------------
4734  public void forAllUserDateTime2 (
4735    short operator,
4736    java.util.Collection   values
4737  ) {
4738    refAddValue(
4739      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
4740      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4741      operator,
4742      values
4743    );
4744  }
4745
4746  public void thereExistsUserDateTime2 (
4747    short operator,
4748    java.util.Collection   values
4749  ) {
4750    refAddValue(
4751      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
4752      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4753      operator,
4754      values
4755    );
4756  }
4757
4758  public void forAllUserDateTime2 (
4759    short operator,
4760    java.util.Date  [] filterValues
4761  ) {
4762    java.util.List   arrayAsList = new java.util.ArrayList  ();
4763    for(int i = 0; i < filterValues.length; i++) {
4764      arrayAsList.add(
4765        filterValues[i]
4766      );
4767    }
4768    forAllUserDateTime2 (
4769      operator,
4770      arrayAsList
4771    );
4772  }
4773
4774  public void thereExistsUserDateTime2 (
4775    short operator,
4776    java.util.Date  [] filterValues
4777  ) {
4778    java.util.List   arrayAsList = new java.util.ArrayList  ();
4779    for(int i = 0; i < filterValues.length; i++) {
4780      arrayAsList.add(
4781        filterValues[i]
4782      );
4783    }
4784    thereExistsUserDateTime2 (
4785      operator,
4786      arrayAsList
4787    );
4788  }
4789
4790  public void orderByUserDateTime2 (
4791    short order
4792  ) {
4793    refAddValue(
4794      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
4795      order
4796    );
4797  }
4798      
4799// ----------------------------------------------------------------------------
4800// Filter/ImplAttributeIsNotStruct
4801// ----------------------------------------------------------------------------
4802  public void forAllUserDateTime3 (
4803    short operator,
4804    java.util.Collection   values
4805  ) {
4806    refAddValue(
4807      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
4808      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4809      operator,
4810      values
4811    );
4812  }
4813
4814  public void thereExistsUserDateTime3 (
4815    short operator,
4816    java.util.Collection   values
4817  ) {
4818    refAddValue(
4819      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
4820      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4821      operator,
4822      values
4823    );
4824  }
4825
4826  public void forAllUserDateTime3 (
4827    short operator,
4828    java.util.Date  [] filterValues
4829  ) {
4830    java.util.List   arrayAsList = new java.util.ArrayList  ();
4831    for(int i = 0; i < filterValues.length; i++) {
4832      arrayAsList.add(
4833        filterValues[i]
4834      );
4835    }
4836    forAllUserDateTime3 (
4837      operator,
4838      arrayAsList
4839    );
4840  }
4841
4842  public void thereExistsUserDateTime3 (
4843    short operator,
4844    java.util.Date  [] filterValues
4845  ) {
4846    java.util.List   arrayAsList = new java.util.ArrayList  ();
4847    for(int i = 0; i < filterValues.length; i++) {
4848      arrayAsList.add(
4849        filterValues[i]
4850      );
4851    }
4852    thereExistsUserDateTime3 (
4853      operator,
4854      arrayAsList
4855    );
4856  }
4857
4858  public void orderByUserDateTime3 (
4859    short order
4860  ) {
4861    refAddValue(
4862      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
4863      order
4864    );
4865  }
4866      
4867// ----------------------------------------------------------------------------
4868// Filter/ImplAttributeIsNotStruct
4869// ----------------------------------------------------------------------------
4870  public void forAllUserDateTime4 (
4871    short operator,
4872    java.util.Collection   values
4873  ) {
4874    refAddValue(
4875      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
4876      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4877      operator,
4878      values
4879    );
4880  }
4881
4882  public void thereExistsUserDateTime4 (
4883    short operator,
4884    java.util.Collection   values
4885  ) {
4886    refAddValue(
4887      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
4888      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4889      operator,
4890      values
4891    );
4892  }
4893
4894  public void forAllUserDateTime4 (
4895    short operator,
4896    java.util.Date  [] filterValues
4897  ) {
4898    java.util.List   arrayAsList = new java.util.ArrayList  ();
4899    for(int i = 0; i < filterValues.length; i++) {
4900      arrayAsList.add(
4901        filterValues[i]
4902      );
4903    }
4904    forAllUserDateTime4 (
4905      operator,
4906      arrayAsList
4907    );
4908  }
4909
4910  public void thereExistsUserDateTime4 (
4911    short operator,
4912    java.util.Date  [] filterValues
4913  ) {
4914    java.util.List   arrayAsList = new java.util.ArrayList  ();
4915    for(int i = 0; i < filterValues.length; i++) {
4916      arrayAsList.add(
4917        filterValues[i]
4918      );
4919    }
4920    thereExistsUserDateTime4 (
4921      operator,
4922      arrayAsList
4923    );
4924  }
4925
4926  public void orderByUserDateTime4 (
4927    short order
4928  ) {
4929    refAddValue(
4930      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
4931      order
4932    );
4933  }
4934      
4935// ----------------------------------------------------------------------------
4936// Filter/ImplAttributeIsNotStruct
4937// ----------------------------------------------------------------------------
4938  public void forAllUserNumber0 (
4939    short operator,
4940    java.util.Collection   values
4941  ) {
4942    refAddValue(
4943      "org:opencrx:kernel:generic:CrxObject:userNumber0",
4944      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4945      operator,
4946      values
4947    );
4948  }
4949
4950  public void thereExistsUserNumber0 (
4951    short operator,
4952    java.util.Collection   values
4953  ) {
4954    refAddValue(
4955      "org:opencrx:kernel:generic:CrxObject:userNumber0",
4956      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4957      operator,
4958      values
4959    );
4960  }
4961
4962  public void forAllUserNumber0 (
4963    short operator,
4964    java.math.BigDecimal  [] filterValues
4965  ) {
4966    java.util.List   arrayAsList = new java.util.ArrayList  ();
4967    for(int i = 0; i < filterValues.length; i++) {
4968      arrayAsList.add(
4969        filterValues[i]
4970      );
4971    }
4972    forAllUserNumber0 (
4973      operator,
4974      arrayAsList
4975    );
4976  }
4977
4978  public void thereExistsUserNumber0 (
4979    short operator,
4980    java.math.BigDecimal  [] filterValues
4981  ) {
4982    java.util.List   arrayAsList = new java.util.ArrayList  ();
4983    for(int i = 0; i < filterValues.length; i++) {
4984      arrayAsList.add(
4985        filterValues[i]
4986      );
4987    }
4988    thereExistsUserNumber0 (
4989      operator,
4990      arrayAsList
4991    );
4992  }
4993
4994  public void orderByUserNumber0 (
4995    short order
4996  ) {
4997    refAddValue(
4998      "org:opencrx:kernel:generic:CrxObject:userNumber0",
4999      order
5000    );
5001  }
5002      
5003// ----------------------------------------------------------------------------
5004// Filter/ImplAttributeIsNotStruct
5005// ----------------------------------------------------------------------------
5006  public void forAllUserNumber1 (
5007    short operator,
5008    java.util.Collection   values
5009  ) {
5010    refAddValue(
5011      "org:opencrx:kernel:generic:CrxObject:userNumber1",
5012      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5013      operator,
5014      values
5015    );
5016  }
5017
5018  public void thereExistsUserNumber1 (
5019    short operator,
5020    java.util.Collection   values
5021  ) {
5022    refAddValue(
5023      "org:opencrx:kernel:generic:CrxObject:userNumber1",
5024      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5025      operator,
5026      values
5027    );
5028  }
5029
5030  public void forAllUserNumber1 (
5031    short operator,
5032    java.math.BigDecimal  [] filterValues
5033  ) {
5034    java.util.List   arrayAsList = new java.util.ArrayList  ();
5035    for(int i = 0; i < filterValues.length; i++) {
5036      arrayAsList.add(
5037        filterValues[i]
5038      );
5039    }
5040    forAllUserNumber1 (
5041      operator,
5042      arrayAsList
5043    );
5044  }
5045
5046  public void thereExistsUserNumber1 (
5047    short operator,
5048    java.math.BigDecimal  [] filterValues
5049  ) {
5050    java.util.List   arrayAsList = new java.util.ArrayList  ();
5051    for(int i = 0; i < filterValues.length; i++) {
5052      arrayAsList.add(
5053        filterValues[i]
5054      );
5055    }
5056    thereExistsUserNumber1 (
5057      operator,
5058      arrayAsList
5059    );
5060  }
5061
5062  public void orderByUserNumber1 (
5063    short order
5064  ) {
5065    refAddValue(
5066      "org:opencrx:kernel:generic:CrxObject:userNumber1",
5067      order
5068    );
5069  }
5070      
5071// ----------------------------------------------------------------------------
5072// Filter/ImplAttributeIsNotStruct
5073// ----------------------------------------------------------------------------
5074  public void forAllUserNumber2 (
5075    short operator,
5076    java.util.Collection   values
5077  ) {
5078    refAddValue(
5079      "org:opencrx:kernel:generic:CrxObject:userNumber2",
5080      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5081      operator,
5082      values
5083    );
5084  }
5085
5086  public void thereExistsUserNumber2 (
5087    short operator,
5088    java.util.Collection   values
5089  ) {
5090    refAddValue(
5091      "org:opencrx:kernel:generic:CrxObject:userNumber2",
5092      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5093      operator,
5094      values
5095    );
5096  }
5097
5098  public void forAllUserNumber2 (
5099    short operator,
5100    java.math.BigDecimal  [] filterValues
5101  ) {
5102    java.util.List   arrayAsList = new java.util.ArrayList  ();
5103    for(int i = 0; i < filterValues.length; i++) {
5104      arrayAsList.add(
5105        filterValues[i]
5106      );
5107    }
5108    forAllUserNumber2 (
5109      operator,
5110      arrayAsList
5111    );
5112  }
5113
5114  public void thereExistsUserNumber2 (
5115    short operator,
5116    java.math.BigDecimal  [] filterValues
5117  ) {
5118    java.util.List   arrayAsList = new java.util.ArrayList  ();
5119    for(int i = 0; i < filterValues.length; i++) {
5120      arrayAsList.add(
5121        filterValues[i]
5122      );
5123    }
5124    thereExistsUserNumber2 (
5125      operator,
5126      arrayAsList
5127    );
5128  }
5129
5130  public void orderByUserNumber2 (
5131    short order
5132  ) {
5133    refAddValue(
5134      "org:opencrx:kernel:generic:CrxObject:userNumber2",
5135      order
5136    );
5137  }
5138      
5139// ----------------------------------------------------------------------------
5140// Filter/ImplAttributeIsNotStruct
5141// ----------------------------------------------------------------------------
5142  public void forAllUserNumber3 (
5143    short operator,
5144    java.util.Collection   values
5145  ) {
5146    refAddValue(
5147      "org:opencrx:kernel:generic:CrxObject:userNumber3",
5148      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5149      operator,
5150      values
5151    );
5152  }
5153
5154  public void thereExistsUserNumber3 (
5155    short operator,
5156    java.util.Collection   values
5157  ) {
5158    refAddValue(
5159      "org:opencrx:kernel:generic:CrxObject:userNumber3",
5160      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5161      operator,
5162      values
5163    );
5164  }
5165
5166  public void forAllUserNumber3 (
5167    short operator,
5168    java.math.BigDecimal  [] filterValues
5169  ) {
5170    java.util.List   arrayAsList = new java.util.ArrayList  ();
5171    for(int i = 0; i < filterValues.length; i++) {
5172      arrayAsList.add(
5173        filterValues[i]
5174      );
5175    }
5176    forAllUserNumber3 (
5177      operator,
5178      arrayAsList
5179    );
5180  }
5181
5182  public void thereExistsUserNumber3 (
5183    short operator,
5184    java.math.BigDecimal  [] filterValues
5185  ) {
5186    java.util.List   arrayAsList = new java.util.ArrayList  ();
5187    for(int i = 0; i < filterValues.length; i++) {
5188      arrayAsList.add(
5189        filterValues[i]
5190      );
5191    }
5192    thereExistsUserNumber3 (
5193      operator,
5194      arrayAsList
5195    );
5196  }
5197
5198  public void orderByUserNumber3 (
5199    short order
5200  ) {
5201    refAddValue(
5202      "org:opencrx:kernel:generic:CrxObject:userNumber3",
5203      order
5204    );
5205  }
5206      
5207// ----------------------------------------------------------------------------
5208// Filter/ImplAttributeIsNotStruct
5209// ----------------------------------------------------------------------------
5210  public void forAllUserNumber4 (
5211    short operator,
5212    java.util.Collection   values
5213  ) {
5214    refAddValue(
5215      "org:opencrx:kernel:generic:CrxObject:userNumber4",
5216      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5217      operator,
5218      values
5219    );
5220  }
5221
5222  public void thereExistsUserNumber4 (
5223    short operator,
5224    java.util.Collection   values
5225  ) {
5226    refAddValue(
5227      "org:opencrx:kernel:generic:CrxObject:userNumber4",
5228      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5229      operator,
5230      values
5231    );
5232  }
5233
5234  public void forAllUserNumber4 (
5235    short operator,
5236    java.math.BigDecimal  [] filterValues
5237  ) {
5238    java.util.List   arrayAsList = new java.util.ArrayList  ();
5239    for(int i = 0; i < filterValues.length; i++) {
5240      arrayAsList.add(
5241        filterValues[i]
5242      );
5243    }
5244    forAllUserNumber4 (
5245      operator,
5246      arrayAsList
5247    );
5248  }
5249
5250  public void thereExistsUserNumber4 (
5251    short operator,
5252    java.math.BigDecimal  [] filterValues
5253  ) {
5254    java.util.List   arrayAsList = new java.util.ArrayList  ();
5255    for(int i = 0; i < filterValues.length; i++) {
5256      arrayAsList.add(
5257        filterValues[i]
5258      );
5259    }
5260    thereExistsUserNumber4 (
5261      operator,
5262      arrayAsList
5263    );
5264  }
5265
5266  public void orderByUserNumber4 (
5267    short order
5268  ) {
5269    refAddValue(
5270      "org:opencrx:kernel:generic:CrxObject:userNumber4",
5271      order
5272    );
5273  }
5274      
5275// ----------------------------------------------------------------------------
5276// Filter/ImplAttributeIsNotStruct
5277// ----------------------------------------------------------------------------
5278  public void forAllUserString0 (
5279    short operator,
5280    java.util.Collection   values
5281  ) {
5282    refAddValue(
5283      "org:opencrx:kernel:generic:CrxObject:userString0",
5284      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5285      operator,
5286      values
5287    );
5288  }
5289
5290  public void thereExistsUserString0 (
5291    short operator,
5292    java.util.Collection   values
5293  ) {
5294    refAddValue(
5295      "org:opencrx:kernel:generic:CrxObject:userString0",
5296      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5297      operator,
5298      values
5299    );
5300  }
5301
5302  public void forAllUserString0 (
5303    short operator,
5304    String  [] filterValues
5305  ) {
5306    java.util.List   arrayAsList = new java.util.ArrayList  ();
5307    for(int i = 0; i < filterValues.length; i++) {
5308      arrayAsList.add(
5309        filterValues[i]
5310      );
5311    }
5312    forAllUserString0 (
5313      operator,
5314      arrayAsList
5315    );
5316  }
5317
5318  public void thereExistsUserString0 (
5319    short operator,
5320    String  [] filterValues
5321  ) {
5322    java.util.List   arrayAsList = new java.util.ArrayList  ();
5323    for(int i = 0; i < filterValues.length; i++) {
5324      arrayAsList.add(
5325        filterValues[i]
5326      );
5327    }
5328    thereExistsUserString0 (
5329      operator,
5330      arrayAsList
5331    );
5332  }
5333
5334  public void orderByUserString0 (
5335    short order
5336  ) {
5337    refAddValue(
5338      "org:opencrx:kernel:generic:CrxObject:userString0",
5339      order
5340    );
5341  }
5342      
5343// ----------------------------------------------------------------------------
5344// Filter/ImplAttributeIsNotStruct
5345// ----------------------------------------------------------------------------
5346  public void forAllUserString1 (
5347    short operator,
5348    java.util.Collection   values
5349  ) {
5350    refAddValue(
5351      "org:opencrx:kernel:generic:CrxObject:userString1",
5352      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5353      operator,
5354      values
5355    );
5356  }
5357
5358  public void thereExistsUserString1 (
5359    short operator,
5360    java.util.Collection   values
5361  ) {
5362    refAddValue(
5363      "org:opencrx:kernel:generic:CrxObject:userString1",
5364      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5365      operator,
5366      values
5367    );
5368  }
5369
5370  public void forAllUserString1 (
5371    short operator,
5372    String  [] filterValues
5373  ) {
5374    java.util.List   arrayAsList = new java.util.ArrayList  ();
5375    for(int i = 0; i < filterValues.length; i++) {
5376      arrayAsList.add(
5377        filterValues[i]
5378      );
5379    }
5380    forAllUserString1 (
5381      operator,
5382      arrayAsList
5383    );
5384  }
5385
5386  public void thereExistsUserString1 (
5387    short operator,
5388    String  [] filterValues
5389  ) {
5390    java.util.List   arrayAsList = new java.util.ArrayList  ();
5391    for(int i = 0; i < filterValues.length; i++) {
5392      arrayAsList.add(
5393        filterValues[i]
5394      );
5395    }
5396    thereExistsUserString1 (
5397      operator,
5398      arrayAsList
5399    );
5400  }
5401
5402  public void orderByUserString1 (
5403    short order
5404  ) {
5405    refAddValue(
5406      "org:opencrx:kernel:generic:CrxObject:userString1",
5407      order
5408    );
5409  }
5410      
5411// ----------------------------------------------------------------------------
5412// Filter/ImplAttributeIsNotStruct
5413// ----------------------------------------------------------------------------
5414  public void forAllUserString2 (
5415    short operator,
5416    java.util.Collection   values
5417  ) {
5418    refAddValue(
5419      "org:opencrx:kernel:generic:CrxObject:userString2",
5420      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5421      operator,
5422      values
5423    );
5424  }
5425
5426  public void thereExistsUserString2 (
5427    short operator,
5428    java.util.Collection   values
5429  ) {
5430    refAddValue(
5431      "org:opencrx:kernel:generic:CrxObject:userString2",
5432      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5433      operator,
5434      values
5435    );
5436  }
5437
5438  public void forAllUserString2 (
5439    short operator,
5440    String  [] filterValues
5441  ) {
5442    java.util.List   arrayAsList = new java.util.ArrayList  ();
5443    for(int i = 0; i < filterValues.length; i++) {
5444      arrayAsList.add(
5445        filterValues[i]
5446      );
5447    }
5448    forAllUserString2 (
5449      operator,
5450      arrayAsList
5451    );
5452  }
5453
5454  public void thereExistsUserString2 (
5455    short operator,
5456    String  [] filterValues
5457  ) {
5458    java.util.List   arrayAsList = new java.util.ArrayList  ();
5459    for(int i = 0; i < filterValues.length; i++) {
5460      arrayAsList.add(
5461        filterValues[i]
5462      );
5463    }
5464    thereExistsUserString2 (
5465      operator,
5466      arrayAsList
5467    );
5468  }
5469
5470  public void orderByUserString2 (
5471    short order
5472  ) {
5473    refAddValue(
5474      "org:opencrx:kernel:generic:CrxObject:userString2",
5475      order
5476    );
5477  }
5478      
5479// ----------------------------------------------------------------------------
5480// Filter/ImplAttributeIsNotStruct
5481// ----------------------------------------------------------------------------
5482  public void forAllUserString3 (
5483    short operator,
5484    java.util.Collection   values
5485  ) {
5486    refAddValue(
5487      "org:opencrx:kernel:generic:CrxObject:userString3",
5488      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5489      operator,
5490      values
5491    );
5492  }
5493
5494  public void thereExistsUserString3 (
5495    short operator,
5496    java.util.Collection   values
5497  ) {
5498    refAddValue(
5499      "org:opencrx:kernel:generic:CrxObject:userString3",
5500      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5501      operator,
5502      values
5503    );
5504  }
5505
5506  public void forAllUserString3 (
5507    short operator,
5508    String  [] filterValues
5509  ) {
5510    java.util.List   arrayAsList = new java.util.ArrayList  ();
5511    for(int i = 0; i < filterValues.length; i++) {
5512      arrayAsList.add(
5513        filterValues[i]
5514      );
5515    }
5516    forAllUserString3 (
5517      operator,
5518      arrayAsList
5519    );
5520  }
5521
5522  public void thereExistsUserString3 (
5523    short operator,
5524    String  [] filterValues
5525  ) {
5526    java.util.List   arrayAsList = new java.util.ArrayList  ();
5527    for(int i = 0; i < filterValues.length; i++) {
5528      arrayAsList.add(
5529        filterValues[i]
5530      );
5531    }
5532    thereExistsUserString3 (
5533      operator,
5534      arrayAsList
5535    );
5536  }
5537
5538  public void orderByUserString3 (
5539    short order
5540  ) {
5541    refAddValue(
5542      "org:opencrx:kernel:generic:CrxObject:userString3",
5543      order
5544    );
5545  }
5546      
5547// ----------------------------------------------------------------------------
5548// Filter/ImplAttributeIsNotStruct
5549// ----------------------------------------------------------------------------
5550  public void forAllUserString4 (
5551    short operator,
5552    java.util.Collection   values
5553  ) {
5554    refAddValue(
5555      "org:opencrx:kernel:generic:CrxObject:userString4",
5556      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5557      operator,
5558      values
5559    );
5560  }
5561
5562  public void thereExistsUserString4 (
5563    short operator,
5564    java.util.Collection   values
5565  ) {
5566    refAddValue(
5567      "org:opencrx:kernel:generic:CrxObject:userString4",
5568      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5569      operator,
5570      values
5571    );
5572  }
5573
5574  public void forAllUserString4 (
5575    short operator,
5576    String  [] filterValues
5577  ) {
5578    java.util.List   arrayAsList = new java.util.ArrayList  ();
5579    for(int i = 0; i < filterValues.length; i++) {
5580      arrayAsList.add(
5581        filterValues[i]
5582      );
5583    }
5584    forAllUserString4 (
5585      operator,
5586      arrayAsList
5587    );
5588  }
5589
5590  public void thereExistsUserString4 (
5591    short operator,
5592    String  [] filterValues
5593  ) {
5594    java.util.List   arrayAsList = new java.util.ArrayList  ();
5595    for(int i = 0; i < filterValues.length; i++) {
5596      arrayAsList.add(
5597        filterValues[i]
5598      );
5599    }
5600    thereExistsUserString4 (
5601      operator,
5602      arrayAsList
5603    );
5604  }
5605
5606  public void orderByUserString4 (
5607    short order
5608  ) {
5609    refAddValue(
5610      "org:opencrx:kernel:generic:CrxObject:userString4",
5611      order
5612    );
5613  }
5614      
5615// ----------------------------------------------------------------------------
5616// Filter/ImplReference
5617// ----------------------------------------------------------------------------
5618  public void forAllPicture (
5619    short operator,
5620    org.opencrx.kernel.document1.cci.Media[] filterValues
5621  ) {
5622    java.util.List   arrayAsList = new java.util.ArrayList  ();
5623    for(int i = 0; i < filterValues.length; i++) {
5624      arrayAsList.add(
5625        filterValues[i]
5626      );
5627    }
5628    forAllPicture (
5629      operator,
5630      arrayAsList
5631    );
5632  }
5633
5634  public void thereExistsPicture (
5635    short operator,
5636    org.opencrx.kernel.document1.cci.Media[] filterValues
5637  ) {
5638    java.util.List   arrayAsList = new java.util.ArrayList  ();
5639    for(int i = 0; i < filterValues.length; i++) {
5640      arrayAsList.add(
5641        filterValues[i]
5642      );
5643    }
5644    thereExistsPicture (
5645      operator,
5646      arrayAsList
5647    );
5648  }
5649
5650  public void forAllPicture (
5651    short operator,
5652    java.util.Collection   values
5653  ) {
5654    refAddValue(
5655      "org:opencrx:kernel:generic:Pictured:picture",
5656      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5657      operator,
5658      values
5659    );
5660  }
5661
5662  public void thereExistsPicture (
5663    short operator,
5664    java.util.Collection   values
5665  ) {
5666    refAddValue(
5667      "org:opencrx:kernel:generic:Pictured:picture",
5668      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5669      operator,
5670      values
5671    );
5672  }
5673      
5674// ----------------------------------------------------------------------------
5675// Filter/ImplAttributeIsNotStruct
5676// ----------------------------------------------------------------------------
5677  public void forAllPictureContent (
5678    short operator,
5679    java.util.Collection   values
5680  ) {
5681    refAddValue(
5682      "org:opencrx:kernel:generic:Pictured:pictureContent",
5683      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5684      operator,
5685      values
5686    );
5687  }
5688
5689  public void thereExistsPictureContent (
5690    short operator,
5691    java.util.Collection   values
5692  ) {
5693    refAddValue(
5694      "org:opencrx:kernel:generic:Pictured:pictureContent",
5695      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5696      operator,
5697      values
5698    );
5699  }
5700
5701  public void forAllPictureContent (
5702    short operator,
5703    byte[][] filterValues
5704  ) {
5705    java.util.List   arrayAsList = new java.util.ArrayList  ();
5706    for(int i = 0; i < filterValues.length; i++) {
5707      arrayAsList.add(
5708        filterValues[i]
5709      );
5710    }
5711    forAllPictureContent (
5712      operator,
5713      arrayAsList
5714    );
5715  }
5716
5717  public void thereExistsPictureContent (
5718    short operator,
5719    byte[][] filterValues
5720  ) {
5721    java.util.List   arrayAsList = new java.util.ArrayList  ();
5722    for(int i = 0; i < filterValues.length; i++) {
5723      arrayAsList.add(
5724        filterValues[i]
5725      );
5726    }
5727    thereExistsPictureContent (
5728      operator,
5729      arrayAsList
5730    );
5731  }
5732
5733  public void orderByPictureContent (
5734    short order
5735  ) {
5736    refAddValue(
5737      "org:opencrx:kernel:generic:Pictured:pictureContent",
5738      order
5739    );
5740  }
5741      
5742// ----------------------------------------------------------------------------
5743// Filter/ImplAttributeIsNotStruct
5744// ----------------------------------------------------------------------------
5745  public void forAllPictureContentMimeType (
5746    short operator,
5747    java.util.Collection   values
5748  ) {
5749    refAddValue(
5750      "org:opencrx:kernel:generic:Pictured:pictureContentMimeType",
5751      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5752      operator,
5753      values
5754    );
5755  }
5756
5757  public void thereExistsPictureContentMimeType (
5758    short operator,
5759    java.util.Collection   values
5760  ) {
5761    refAddValue(
5762      "org:opencrx:kernel:generic:Pictured:pictureContentMimeType",
5763      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5764      operator,
5765      values
5766    );
5767  }
5768
5769  public void forAllPictureContentMimeType (
5770    short operator,
5771    String  [] filterValues
5772  ) {
5773    java.util.List   arrayAsList = new java.util.ArrayList  ();
5774    for(int i = 0; i < filterValues.length; i++) {
5775      arrayAsList.add(
5776        filterValues[i]
5777      );
5778    }
5779    forAllPictureContentMimeType (
5780      operator,
5781      arrayAsList
5782    );
5783  }
5784
5785  public void thereExistsPictureContentMimeType (
5786    short operator,
5787    String  [] filterValues
5788  ) {
5789    java.util.List   arrayAsList = new java.util.ArrayList  ();
5790    for(int i = 0; i < filterValues.length; i++) {
5791      arrayAsList.add(
5792        filterValues[i]
5793      );
5794    }
5795    thereExistsPictureContentMimeType (
5796      operator,
5797      arrayAsList
5798    );
5799  }
5800
5801  public void orderByPictureContentMimeType (
5802    short order
5803  ) {
5804    refAddValue(
5805      "org:opencrx:kernel:generic:Pictured:pictureContentMimeType",
5806      order
5807    );
5808  }
5809      
5810// ----------------------------------------------------------------------------
5811// Filter/ImplAttributeIsNotStruct
5812// ----------------------------------------------------------------------------
5813  public void forAllPictureContentName (
5814    short operator,
5815    java.util.Collection   values
5816  ) {
5817    refAddValue(
5818      "org:opencrx:kernel:generic:Pictured:pictureContentName",
5819      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5820      operator,
5821      values
5822    );
5823  }
5824
5825  public void thereExistsPictureContentName (
5826    short operator,
5827    java.util.Collection   values
5828  ) {
5829    refAddValue(
5830      "org:opencrx:kernel:generic:Pictured:pictureContentName",
5831      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5832      operator,
5833      values
5834    );
5835  }
5836
5837  public void forAllPictureContentName (
5838    short operator,
5839    String  [] filterValues
5840  ) {
5841    java.util.List   arrayAsList = new java.util.ArrayList  ();
5842    for(int i = 0; i < filterValues.length; i++) {
5843      arrayAsList.add(
5844        filterValues[i]
5845      );
5846    }
5847    forAllPictureContentName (
5848      operator,
5849      arrayAsList
5850    );
5851  }
5852
5853  public void thereExistsPictureContentName (
5854    short operator,
5855    String  [] filterValues
5856  ) {
5857    java.util.List   arrayAsList = new java.util.ArrayList  ();
5858    for(int i = 0; i < filterValues.length; i++) {
5859      arrayAsList.add(
5860        filterValues[i]
5861      );
5862    }
5863    thereExistsPictureContentName (
5864      operator,
5865      arrayAsList
5866    );
5867  }
5868
5869  public void orderByPictureContentName (
5870    short order
5871  ) {
5872    refAddValue(
5873      "org:opencrx:kernel:generic:Pictured:pictureContentName",
5874      order
5875    );
5876  }
5877      
5878// ----------------------------------------------------------------------------
5879// Filter/ImplAttributeIsNotStruct
5880// ----------------------------------------------------------------------------
5881  public void forAllCreatedAt (
5882    short operator,
5883    java.util.Collection   values
5884  ) {
5885    refAddValue(
5886      "org:openmdx:base:BasicObject:createdAt",
5887      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5888      operator,
5889      values
5890    );
5891  }
5892
5893  public void thereExistsCreatedAt (
5894    short operator,
5895    java.util.Collection   values
5896  ) {
5897    refAddValue(
5898      "org:openmdx:base:BasicObject:createdAt",
5899      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5900      operator,
5901      values
5902    );
5903  }
5904
5905  public void forAllCreatedAt (
5906    short operator,
5907    java.util.Date  [] filterValues
5908  ) {
5909    java.util.List   arrayAsList = new java.util.ArrayList  ();
5910    for(int i = 0; i < filterValues.length; i++) {
5911      arrayAsList.add(
5912        filterValues[i]
5913      );
5914    }
5915    forAllCreatedAt (
5916      operator,
5917      arrayAsList
5918    );
5919  }
5920
5921  public void thereExistsCreatedAt (
5922    short operator,
5923    java.util.Date  [] filterValues
5924  ) {
5925    java.util.List   arrayAsList = new java.util.ArrayList  ();
5926    for(int i = 0; i < filterValues.length; i++) {
5927      arrayAsList.add(
5928        filterValues[i]
5929      );
5930    }
5931    thereExistsCreatedAt (
5932      operator,
5933      arrayAsList
5934    );
5935  }
5936
5937  public void orderByCreatedAt (
5938    short order
5939  ) {
5940    refAddValue(
5941      "org:openmdx:base:BasicObject:createdAt",
5942      order
5943    );
5944  }
5945      
5946// ----------------------------------------------------------------------------
5947// Filter/ImplAttributeIsNotStruct
5948// ----------------------------------------------------------------------------
5949  public void forAllCreatedBy (
5950    short operator,
5951    java.util.Collection   values
5952  ) {
5953    refAddValue(
5954      "org:openmdx:base:BasicObject:createdBy",
5955      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
5956      operator,
5957      values
5958    );
5959  }
5960
5961  public void thereExistsCreatedBy (
5962    short operator,
5963    java.util.Collection   values
5964  ) {
5965    refAddValue(
5966      "org:openmdx:base:BasicObject:createdBy",
5967      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
5968      operator,
5969      values
5970    );
5971  }
5972
5973  public void forAllCreatedBy (
5974    short operator,
5975    String  [] filterValues
5976  ) {
5977    java.util.List   arrayAsList = new java.util.ArrayList  ();
5978    for(int i = 0; i < filterValues.length; i++) {
5979      arrayAsList.add(
5980        filterValues[i]
5981      );
5982    }
5983    forAllCreatedBy (
5984      operator,
5985      arrayAsList
5986    );
5987  }
5988
5989  public void thereExistsCreatedBy (
5990    short operator,
5991    String  [] filterValues
5992  ) {
5993    java.util.List   arrayAsList = new java.util.ArrayList  ();
5994    for(int i = 0; i < filterValues.length; i++) {
5995      arrayAsList.add(
5996        filterValues[i]
5997      );
5998    }
5999    thereExistsCreatedBy (
6000      operator,
6001      arrayAsList
6002    );
6003  }
6004
6005  public void orderByCreatedBy (
6006    short order
6007  ) {
6008    refAddValue(
6009      "org:openmdx:base:BasicObject:createdBy",
6010      order
6011    );
6012  }
6013      
6014// ----------------------------------------------------------------------------
6015// Filter/ImplAttributeIsNotStruct
6016// ----------------------------------------------------------------------------
6017  public void forAllModifiedAt (
6018    short operator,
6019    java.util.Collection   values
6020  ) {
6021    refAddValue(
6022      "org:openmdx:base:BasicObject:modifiedAt",
6023      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
6024      operator,
6025      values
6026    );
6027  }
6028
6029  public void thereExistsModifiedAt (
6030    short operator,
6031    java.util.Collection   values
6032  ) {
6033    refAddValue(
6034      "org:openmdx:base:BasicObject:modifiedAt",
6035      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
6036      operator,
6037      values
6038    );
6039  }
6040
6041  public void forAllModifiedAt (
6042    short operator,
6043    java.util.Date  [] filterValues
6044  ) {
6045    java.util.List   arrayAsList = new java.util.ArrayList  ();
6046    for(int i = 0; i < filterValues.length; i++) {
6047      arrayAsList.add(
6048        filterValues[i]
6049      );
6050    }
6051    forAllModifiedAt (
6052      operator,
6053      arrayAsList
6054    );
6055  }
6056
6057  public void thereExistsModifiedAt (
6058    short operator,
6059    java.util.Date  [] filterValues
6060  ) {
6061    java.util.List   arrayAsList = new java.util.ArrayList  ();
6062    for(int i = 0; i < filterValues.length; i++) {
6063      arrayAsList.add(
6064        filterValues[i]
6065      );
6066    }
6067    thereExistsModifiedAt (
6068      operator,
6069      arrayAsList
6070    );
6071  }
6072
6073  public void orderByModifiedAt (
6074    short order
6075  ) {
6076    refAddValue(
6077      "org:openmdx:base:BasicObject:modifiedAt",
6078      order
6079    );
6080  }
6081      
6082// ----------------------------------------------------------------------------
6083// Filter/ImplAttributeIsNotStruct
6084// ----------------------------------------------------------------------------
6085  public void forAllModifiedBy (
6086    short operator,
6087    java.util.Collection   values
6088  ) {
6089    refAddValue(
6090      "org:openmdx:base:BasicObject:modifiedBy",
6091      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
6092      operator,
6093      values
6094    );
6095  }
6096
6097  public void thereExistsModifiedBy (
6098    short operator,
6099    java.util.Collection   values
6100  ) {
6101    refAddValue(
6102      "org:openmdx:base:BasicObject:modifiedBy",
6103      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
6104      operator,
6105      values
6106    );
6107  }
6108
6109  public void forAllModifiedBy (
6110    short operator,
6111    String  [] filterValues
6112  ) {
6113    java.util.List   arrayAsList = new java.util.ArrayList  ();
6114    for(int i = 0; i < filterValues.length; i++) {
6115      arrayAsList.add(
6116        filterValues[i]
6117      );
6118    }
6119    forAllModifiedBy (
6120      operator,
6121      arrayAsList
6122    );
6123  }
6124
6125  public void thereExistsModifiedBy (
6126    short operator,
6127    String  [] filterValues
6128  ) {
6129    java.util.List   arrayAsList = new java.util.ArrayList  ();
6130    for(int i = 0; i < filterValues.length; i++) {
6131      arrayAsList.add(
6132        filterValues[i]
6133      );
6134    }
6135    thereExistsModifiedBy (
6136      operator,
6137      arrayAsList
6138    );
6139  }
6140
6141  public void orderByModifiedBy (
6142    short order
6143  ) {
6144    refAddValue(
6145      "org:openmdx:base:BasicObject:modifiedBy",
6146      order
6147    );
6148  }
6149      
6150// ----------------------------------------------------------------------------
6151// Filter/ImplReference
6152// ----------------------------------------------------------------------------
6153  public void forAllContext (
6154    short operator,
6155    org.openmdx.base.cci.Context[] filterValues
6156  ) {
6157    java.util.List   arrayAsList = new java.util.ArrayList  ();
6158    for(int i = 0; i < filterValues.length; i++) {
6159      arrayAsList.add(
6160        filterValues[i]
6161      );
6162    }
6163    forAllContext (
6164      operator,
6165      arrayAsList
6166    );
6167  }
6168
6169  public void thereExistsContext (
6170    short operator,
6171    org.openmdx.base.cci.Context[] filterValues
6172  ) {
6173    java.util.List   arrayAsList = new java.util.ArrayList  ();
6174    for(int i = 0; i < filterValues.length; i++) {
6175      arrayAsList.add(
6176        filterValues[i]
6177      );
6178    }
6179    thereExistsContext (
6180      operator,
6181      arrayAsList
6182    );
6183  }
6184
6185  public void forAllContext (
6186    short operator,
6187    java.util.Collection   values
6188  ) {
6189    refAddValue(
6190      "org:openmdx:base:ContextCapable:context",
6191      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
6192      operator,
6193      values
6194    );
6195  }
6196
6197  public void thereExistsContext (
6198    short operator,
6199    java.util.Collection   values
6200  ) {
6201    refAddValue(
6202      "org:openmdx:base:ContextCapable:context",
6203      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
6204      operator,
6205      values
6206    );
6207  }
6208      
6209// ----------------------------------------------------------------------------
6210// Filter/ImplAttributeIsNotStruct
6211// ----------------------------------------------------------------------------
6212  public void forAllIdentity (
6213    short operator,
6214    java.util.Collection   values
6215  ) {
6216    refAddValue(
6217      "org:openmdx:base:ExtentCapable:identity",
6218      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
6219      operator,
6220      values
6221    );
6222  }
6223
6224  public void thereExistsIdentity (
6225    short operator,
6226    java.util.Collection   values
6227  ) {
6228    refAddValue(
6229      "org:openmdx:base:ExtentCapable:identity",
6230      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
6231      operator,
6232      values
6233    );
6234  }
6235
6236  public void forAllIdentity (
6237    short operator,
6238    String  [] filterValues
6239  ) {
6240    java.util.List   arrayAsList = new java.util.ArrayList  ();
6241    for(int i = 0; i < filterValues.length; i++) {
6242      arrayAsList.add(
6243        filterValues[i]
6244      );
6245    }
6246    forAllIdentity (
6247      operator,
6248      arrayAsList
6249    );
6250  }
6251
6252  public void thereExistsIdentity (
6253    short operator,
6254    String  [] filterValues
6255  ) {
6256    java.util.List   arrayAsList = new java.util.ArrayList  ();
6257    for(int i = 0; i < filterValues.length; i++) {
6258      arrayAsList.add(
6259        filterValues[i]
6260      );
6261    }
6262    thereExistsIdentity (
6263      operator,
6264      arrayAsList
6265    );
6266  }
6267
6268  public void orderByIdentity (
6269    short order
6270  ) {
6271    refAddValue(
6272      "org:openmdx:base:ExtentCapable:identity",
6273      order
6274    );
6275  }
6276      
6277// ----------------------------------------------------------------------------
6278// Filter/ImplEnd
6279// ----------------------------------------------------------------------------
6280}        
6281
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags