LegalEntityFilterImpl


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 LegalEntityFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements LegalEntityFilter {
18  
19    public LegalEntityFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:account1:LegalEntity",
25        null,
26        null
27      );
28    }
29  
30    public LegalEntityFilterImpl(
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:LegalEntity",
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 forAllIndustry (
709     short operator,
710     java.util.Collection   values
711   ) {
712     refAddValue(
713       "org:opencrx:kernel:account1:LegalEntity:industry",
714       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
715       operator,
716       values
717     );
718   }
719 
720   public void thereExistsIndustry (
721     short operator,
722     java.util.Collection   values
723   ) {
724     refAddValue(
725       "org:opencrx:kernel:account1:LegalEntity:industry",
726       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
727       operator,
728       values
729     );
730   }
731 
732   public void forAllIndustry (
733     short operator,
734     short[] filterValues
735   ) {
736     java.util.List   arrayAsList = new java.util.ArrayList  ();
737     for(int i = 0; i < filterValues.length; i++) {
738       arrayAsList.add(
739         new Short  (filterValues[i])
740       );
741     }
742     forAllIndustry (
743       operator,
744       arrayAsList
745     );
746   }
747 
748   public void thereExistsIndustry (
749     short operator,
750     short[] filterValues
751   ) {
752     java.util.List   arrayAsList = new java.util.ArrayList  ();
753     for(int i = 0; i < filterValues.length; i++) {
754       arrayAsList.add(
755         new Short  (filterValues[i])
756       );
757     }
758     thereExistsIndustry (
759       operator,
760       arrayAsList
761     );
762   }
763 
764   public void orderByIndustry (
765     short order
766   ) {
767     refAddValue(
768       "org:opencrx:kernel:account1:LegalEntity:industry",
769       order
770     );
771   }
772       
773 // ----------------------------------------------------------------------------
774 // Filter/ImplAttributeIsNotStruct
775 // ----------------------------------------------------------------------------
776   public void forAllName (
777     short operator,
778     java.util.Collection   values
779   ) {
780     refAddValue(
781       "org:opencrx:kernel:account1:LegalEntity:name",
782       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
783       operator,
784       values
785     );
786   }
787 
788   public void thereExistsName (
789     short operator,
790     java.util.Collection   values
791   ) {
792     refAddValue(
793       "org:opencrx:kernel:account1:LegalEntity:name",
794       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
795       operator,
796       values
797     );
798   }
799 
800   public void forAllName (
801     short operator,
802     String  [] 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     forAllName (
811       operator,
812       arrayAsList
813     );
814   }
815 
816   public void thereExistsName (
817     short operator,
818     String  [] 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     thereExistsName (
827       operator,
828       arrayAsList
829     );
830   }
831 
832   public void orderByName (
833     short order
834   ) {
835     refAddValue(
836       "org:opencrx:kernel:account1:LegalEntity:name",
837       order
838     );
839   }
840       
841 // ----------------------------------------------------------------------------
842 // Filter/ImplAttributeIsNotStruct
843 // ----------------------------------------------------------------------------
844   public void forAllNumberOfEmployees (
845     short operator,
846     java.util.Collection   values
847   ) {
848     refAddValue(
849       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployees",
850       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
851       operator,
852       values
853     );
854   }
855 
856   public void thereExistsNumberOfEmployees (
857     short operator,
858     java.util.Collection   values
859   ) {
860     refAddValue(
861       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployees",
862       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
863       operator,
864       values
865     );
866   }
867 
868   public void forAllNumberOfEmployees (
869     short operator,
870     int[] 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 Integer  (filterValues[i])
876       );
877     }
878     forAllNumberOfEmployees (
879       operator,
880       arrayAsList
881     );
882   }
883 
884   public void thereExistsNumberOfEmployees (
885     short operator,
886     int[] 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 Integer  (filterValues[i])
892       );
893     }
894     thereExistsNumberOfEmployees (
895       operator,
896       arrayAsList
897     );
898   }
899 
900   public void orderByNumberOfEmployees (
901     short order
902   ) {
903     refAddValue(
904       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployees",
905       order
906     );
907   }
908       
909 // ----------------------------------------------------------------------------
910 // Filter/ImplAttributeIsNotStruct
911 // ----------------------------------------------------------------------------
912   public void forAllNumberOfEmployeesCategory (
913     short operator,
914     java.util.Collection   values
915   ) {
916     refAddValue(
917       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployeesCategory",
918       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
919       operator,
920       values
921     );
922   }
923 
924   public void thereExistsNumberOfEmployeesCategory (
925     short operator,
926     java.util.Collection   values
927   ) {
928     refAddValue(
929       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployeesCategory",
930       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
931       operator,
932       values
933     );
934   }
935 
936   public void forAllNumberOfEmployeesCategory (
937     short operator,
938     short[] filterValues
939   ) {
940     java.util.List   arrayAsList = new java.util.ArrayList  ();
941     for(int i = 0; i < filterValues.length; i++) {
942       arrayAsList.add(
943         new Short  (filterValues[i])
944       );
945     }
946     forAllNumberOfEmployeesCategory (
947       operator,
948       arrayAsList
949     );
950   }
951 
952   public void thereExistsNumberOfEmployeesCategory (
953     short operator,
954     short[] filterValues
955   ) {
956     java.util.List   arrayAsList = new java.util.ArrayList  ();
957     for(int i = 0; i < filterValues.length; i++) {
958       arrayAsList.add(
959         new Short  (filterValues[i])
960       );
961     }
962     thereExistsNumberOfEmployeesCategory (
963       operator,
964       arrayAsList
965     );
966   }
967 
968   public void orderByNumberOfEmployeesCategory (
969     short order
970   ) {
971     refAddValue(
972       "org:opencrx:kernel:account1:LegalEntity:numberOfEmployeesCategory",
973       order
974     );
975   }
976       
977 // ----------------------------------------------------------------------------
978 // Filter/ImplReference
979 // ----------------------------------------------------------------------------
980   public void forAllOrganizationalUnit (
981     short operator,
982     org.opencrx.kernel.account1.cci.OrganizationalUnit[] filterValues
983   ) {
984     java.util.List   arrayAsList = new java.util.ArrayList  ();
985     for(int i = 0; i < filterValues.length; i++) {
986       arrayAsList.add(
987         filterValues[i]
988       );
989     }
990     forAllOrganizationalUnit (
991       operator,
992       arrayAsList
993     );
994   }
995 
996   public void thereExistsOrganizationalUnit (
997     short operator,
998     org.opencrx.kernel.account1.cci.OrganizationalUnit[] filterValues
999   ) {
1000    java.util.List   arrayAsList = new java.util.ArrayList  ();
1001    for(int i = 0; i < filterValues.length; i++) {
1002      arrayAsList.add(
1003        filterValues[i]
1004      );
1005    }
1006    thereExistsOrganizationalUnit (
1007      operator,
1008      arrayAsList
1009    );
1010  }
1011
1012  public void forAllOrganizationalUnit (
1013    short operator,
1014    java.util.Collection   values
1015  ) {
1016    refAddValue(
1017      "org:opencrx:kernel:account1:LegalEntity:organizationalUnit",
1018      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1019      operator,
1020      values
1021    );
1022  }
1023
1024  public void thereExistsOrganizationalUnit (
1025    short operator,
1026    java.util.Collection   values
1027  ) {
1028    refAddValue(
1029      "org:opencrx:kernel:account1:LegalEntity:organizationalUnit",
1030      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1031      operator,
1032      values
1033    );
1034  }
1035      
1036// ----------------------------------------------------------------------------
1037// Filter/ImplAttributeIsNotStruct
1038// ----------------------------------------------------------------------------
1039  public void forAllStockExchange (
1040    short operator,
1041    java.util.Collection   values
1042  ) {
1043    refAddValue(
1044      "org:opencrx:kernel:account1:LegalEntity:stockExchange",
1045      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1046      operator,
1047      values
1048    );
1049  }
1050
1051  public void thereExistsStockExchange (
1052    short operator,
1053    java.util.Collection   values
1054  ) {
1055    refAddValue(
1056      "org:opencrx:kernel:account1:LegalEntity:stockExchange",
1057      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1058      operator,
1059      values
1060    );
1061  }
1062
1063  public void forAllStockExchange (
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    forAllStockExchange (
1074      operator,
1075      arrayAsList
1076    );
1077  }
1078
1079  public void thereExistsStockExchange (
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    thereExistsStockExchange (
1090      operator,
1091      arrayAsList
1092    );
1093  }
1094
1095  public void orderByStockExchange (
1096    short order
1097  ) {
1098    refAddValue(
1099      "org:opencrx:kernel:account1:LegalEntity:stockExchange",
1100      order
1101    );
1102  }
1103      
1104// ----------------------------------------------------------------------------
1105// Filter/ImplAttributeIsNotStruct
1106// ----------------------------------------------------------------------------
1107  public void forAllTickerSymbol (
1108    short operator,
1109    java.util.Collection   values
1110  ) {
1111    refAddValue(
1112      "org:opencrx:kernel:account1:LegalEntity:tickerSymbol",
1113      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1114      operator,
1115      values
1116    );
1117  }
1118
1119  public void thereExistsTickerSymbol (
1120    short operator,
1121    java.util.Collection   values
1122  ) {
1123    refAddValue(
1124      "org:opencrx:kernel:account1:LegalEntity:tickerSymbol",
1125      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1126      operator,
1127      values
1128    );
1129  }
1130
1131  public void forAllTickerSymbol (
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    forAllTickerSymbol (
1142      operator,
1143      arrayAsList
1144    );
1145  }
1146
1147  public void thereExistsTickerSymbol (
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    thereExistsTickerSymbol (
1158      operator,
1159      arrayAsList
1160    );
1161  }
1162
1163  public void orderByTickerSymbol (
1164    short order
1165  ) {
1166    refAddValue(
1167      "org:opencrx:kernel:account1:LegalEntity:tickerSymbol",
1168      order
1169    );
1170  }
1171      
1172// ----------------------------------------------------------------------------
1173// Filter/ImplAttributeIsNotStruct
1174// ----------------------------------------------------------------------------
1175  public void forAllAccessLevelBrowse (
1176    short operator,
1177    java.util.Collection   values
1178  ) {
1179    refAddValue(
1180      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1181      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1182      operator,
1183      values
1184    );
1185  }
1186
1187  public void thereExistsAccessLevelBrowse (
1188    short operator,
1189    java.util.Collection   values
1190  ) {
1191    refAddValue(
1192      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1193      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1194      operator,
1195      values
1196    );
1197  }
1198
1199  public void forAllAccessLevelBrowse (
1200    short operator,
1201    short[] filterValues
1202  ) {
1203    java.util.List   arrayAsList = new java.util.ArrayList  ();
1204    for(int i = 0; i < filterValues.length; i++) {
1205      arrayAsList.add(
1206        new Short  (filterValues[i])
1207      );
1208    }
1209    forAllAccessLevelBrowse (
1210      operator,
1211      arrayAsList
1212    );
1213  }
1214
1215  public void thereExistsAccessLevelBrowse (
1216    short operator,
1217    short[] filterValues
1218  ) {
1219    java.util.List   arrayAsList = new java.util.ArrayList  ();
1220    for(int i = 0; i < filterValues.length; i++) {
1221      arrayAsList.add(
1222        new Short  (filterValues[i])
1223      );
1224    }
1225    thereExistsAccessLevelBrowse (
1226      operator,
1227      arrayAsList
1228    );
1229  }
1230
1231  public void orderByAccessLevelBrowse (
1232    short order
1233  ) {
1234    refAddValue(
1235      "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
1236      order
1237    );
1238  }
1239      
1240// ----------------------------------------------------------------------------
1241// Filter/ImplAttributeIsNotStruct
1242// ----------------------------------------------------------------------------
1243  public void forAllAccessLevelDelete (
1244    short operator,
1245    java.util.Collection   values
1246  ) {
1247    refAddValue(
1248      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1249      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1250      operator,
1251      values
1252    );
1253  }
1254
1255  public void thereExistsAccessLevelDelete (
1256    short operator,
1257    java.util.Collection   values
1258  ) {
1259    refAddValue(
1260      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1261      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1262      operator,
1263      values
1264    );
1265  }
1266
1267  public void forAllAccessLevelDelete (
1268    short operator,
1269    short[] filterValues
1270  ) {
1271    java.util.List   arrayAsList = new java.util.ArrayList  ();
1272    for(int i = 0; i < filterValues.length; i++) {
1273      arrayAsList.add(
1274        new Short  (filterValues[i])
1275      );
1276    }
1277    forAllAccessLevelDelete (
1278      operator,
1279      arrayAsList
1280    );
1281  }
1282
1283  public void thereExistsAccessLevelDelete (
1284    short operator,
1285    short[] filterValues
1286  ) {
1287    java.util.List   arrayAsList = new java.util.ArrayList  ();
1288    for(int i = 0; i < filterValues.length; i++) {
1289      arrayAsList.add(
1290        new Short  (filterValues[i])
1291      );
1292    }
1293    thereExistsAccessLevelDelete (
1294      operator,
1295      arrayAsList
1296    );
1297  }
1298
1299  public void orderByAccessLevelDelete (
1300    short order
1301  ) {
1302    refAddValue(
1303      "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
1304      order
1305    );
1306  }
1307      
1308// ----------------------------------------------------------------------------
1309// Filter/ImplAttributeIsNotStruct
1310// ----------------------------------------------------------------------------
1311  public void forAllAccessLevelUpdate (
1312    short operator,
1313    java.util.Collection   values
1314  ) {
1315    refAddValue(
1316      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1317      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1318      operator,
1319      values
1320    );
1321  }
1322
1323  public void thereExistsAccessLevelUpdate (
1324    short operator,
1325    java.util.Collection   values
1326  ) {
1327    refAddValue(
1328      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1329      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1330      operator,
1331      values
1332    );
1333  }
1334
1335  public void forAllAccessLevelUpdate (
1336    short operator,
1337    short[] filterValues
1338  ) {
1339    java.util.List   arrayAsList = new java.util.ArrayList  ();
1340    for(int i = 0; i < filterValues.length; i++) {
1341      arrayAsList.add(
1342        new Short  (filterValues[i])
1343      );
1344    }
1345    forAllAccessLevelUpdate (
1346      operator,
1347      arrayAsList
1348    );
1349  }
1350
1351  public void thereExistsAccessLevelUpdate (
1352    short operator,
1353    short[] filterValues
1354  ) {
1355    java.util.List   arrayAsList = new java.util.ArrayList  ();
1356    for(int i = 0; i < filterValues.length; i++) {
1357      arrayAsList.add(
1358        new Short  (filterValues[i])
1359      );
1360    }
1361    thereExistsAccessLevelUpdate (
1362      operator,
1363      arrayAsList
1364    );
1365  }
1366
1367  public void orderByAccessLevelUpdate (
1368    short order
1369  ) {
1370    refAddValue(
1371      "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
1372      order
1373    );
1374  }
1375      
1376// ----------------------------------------------------------------------------
1377// Filter/ImplAttributeIsNotStruct
1378// ----------------------------------------------------------------------------
1379  public void forAllOwner (
1380    short operator,
1381    java.util.Collection   values
1382  ) {
1383    refAddValue(
1384      "org:opencrx:kernel:base:SecureObject:owner",
1385      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1386      operator,
1387      values
1388    );
1389  }
1390
1391  public void thereExistsOwner (
1392    short operator,
1393    java.util.Collection   values
1394  ) {
1395    refAddValue(
1396      "org:opencrx:kernel:base:SecureObject:owner",
1397      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1398      operator,
1399      values
1400    );
1401  }
1402
1403  public void forAllOwner (
1404    short operator,
1405    String  [] filterValues
1406  ) {
1407    java.util.List   arrayAsList = new java.util.ArrayList  ();
1408    for(int i = 0; i < filterValues.length; i++) {
1409      arrayAsList.add(
1410        filterValues[i]
1411      );
1412    }
1413    forAllOwner (
1414      operator,
1415      arrayAsList
1416    );
1417  }
1418
1419  public void thereExistsOwner (
1420    short operator,
1421    String  [] filterValues
1422  ) {
1423    java.util.List   arrayAsList = new java.util.ArrayList  ();
1424    for(int i = 0; i < filterValues.length; i++) {
1425      arrayAsList.add(
1426        filterValues[i]
1427      );
1428    }
1429    thereExistsOwner (
1430      operator,
1431      arrayAsList
1432    );
1433  }
1434
1435  public void orderByOwner (
1436    short order
1437  ) {
1438    refAddValue(
1439      "org:opencrx:kernel:base:SecureObject:owner",
1440      order
1441    );
1442  }
1443      
1444// ----------------------------------------------------------------------------
1445// Filter/ImplReference
1446// ----------------------------------------------------------------------------
1447  public void forAllOwningGroup (
1448    short operator,
1449    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
1450  ) {
1451    java.util.List   arrayAsList = new java.util.ArrayList  ();
1452    for(int i = 0; i < filterValues.length; i++) {
1453      arrayAsList.add(
1454        filterValues[i]
1455      );
1456    }
1457    forAllOwningGroup (
1458      operator,
1459      arrayAsList
1460    );
1461  }
1462
1463  public void thereExistsOwningGroup (
1464    short operator,
1465    org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
1466  ) {
1467    java.util.List   arrayAsList = new java.util.ArrayList  ();
1468    for(int i = 0; i < filterValues.length; i++) {
1469      arrayAsList.add(
1470        filterValues[i]
1471      );
1472    }
1473    thereExistsOwningGroup (
1474      operator,
1475      arrayAsList
1476    );
1477  }
1478
1479  public void forAllOwningGroup (
1480    short operator,
1481    java.util.Collection   values
1482  ) {
1483    refAddValue(
1484      "org:opencrx:kernel:base:SecureObject:owningGroup",
1485      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1486      operator,
1487      values
1488    );
1489  }
1490
1491  public void thereExistsOwningGroup (
1492    short operator,
1493    java.util.Collection   values
1494  ) {
1495    refAddValue(
1496      "org:opencrx:kernel:base:SecureObject:owningGroup",
1497      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1498      operator,
1499      values
1500    );
1501  }
1502      
1503// ----------------------------------------------------------------------------
1504// Filter/ImplReference
1505// ----------------------------------------------------------------------------
1506  public void forAllOwningUser (
1507    short operator,
1508    org.opencrx.security.realm1.cci.User[] filterValues
1509  ) {
1510    java.util.List   arrayAsList = new java.util.ArrayList  ();
1511    for(int i = 0; i < filterValues.length; i++) {
1512      arrayAsList.add(
1513        filterValues[i]
1514      );
1515    }
1516    forAllOwningUser (
1517      operator,
1518      arrayAsList
1519    );
1520  }
1521
1522  public void thereExistsOwningUser (
1523    short operator,
1524    org.opencrx.security.realm1.cci.User[] filterValues
1525  ) {
1526    java.util.List   arrayAsList = new java.util.ArrayList  ();
1527    for(int i = 0; i < filterValues.length; i++) {
1528      arrayAsList.add(
1529        filterValues[i]
1530      );
1531    }
1532    thereExistsOwningUser (
1533      operator,
1534      arrayAsList
1535    );
1536  }
1537
1538  public void forAllOwningUser (
1539    short operator,
1540    java.util.Collection   values
1541  ) {
1542    refAddValue(
1543      "org:opencrx:kernel:base:SecureObject:owningUser",
1544      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1545      operator,
1546      values
1547    );
1548  }
1549
1550  public void thereExistsOwningUser (
1551    short operator,
1552    java.util.Collection   values
1553  ) {
1554    refAddValue(
1555      "org:opencrx:kernel:base:SecureObject:owningUser",
1556      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1557      operator,
1558      values
1559    );
1560  }
1561      
1562// ----------------------------------------------------------------------------
1563// Filter/ImplAttributeIsNotStruct
1564// ----------------------------------------------------------------------------
1565  public void forAllCategory (
1566    short operator,
1567    java.util.Collection   values
1568  ) {
1569    refAddValue(
1570      "org:opencrx:kernel:generic:CrxObject:category",
1571      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1572      operator,
1573      values
1574    );
1575  }
1576
1577  public void thereExistsCategory (
1578    short operator,
1579    java.util.Collection   values
1580  ) {
1581    refAddValue(
1582      "org:opencrx:kernel:generic:CrxObject:category",
1583      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1584      operator,
1585      values
1586    );
1587  }
1588
1589  public void forAllCategory (
1590    short operator,
1591    String  [] filterValues
1592  ) {
1593    java.util.List   arrayAsList = new java.util.ArrayList  ();
1594    for(int i = 0; i < filterValues.length; i++) {
1595      arrayAsList.add(
1596        filterValues[i]
1597      );
1598    }
1599    forAllCategory (
1600      operator,
1601      arrayAsList
1602    );
1603  }
1604
1605  public void thereExistsCategory (
1606    short operator,
1607    String  [] filterValues
1608  ) {
1609    java.util.List   arrayAsList = new java.util.ArrayList  ();
1610    for(int i = 0; i < filterValues.length; i++) {
1611      arrayAsList.add(
1612        filterValues[i]
1613      );
1614    }
1615    thereExistsCategory (
1616      operator,
1617      arrayAsList
1618    );
1619  }
1620
1621  public void orderByCategory (
1622    short order
1623  ) {
1624    refAddValue(
1625      "org:opencrx:kernel:generic:CrxObject:category",
1626      order
1627    );
1628  }
1629      
1630// ----------------------------------------------------------------------------
1631// Filter/ImplAttributeIsNotStruct
1632// ----------------------------------------------------------------------------
1633  public void forAllDisabled (
1634    short operator,
1635    java.util.Collection   values
1636  ) {
1637    refAddValue(
1638      "org:opencrx:kernel:generic:CrxObject:disabled",
1639      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1640      operator,
1641      values
1642    );
1643  }
1644
1645  public void thereExistsDisabled (
1646    short operator,
1647    java.util.Collection   values
1648  ) {
1649    refAddValue(
1650      "org:opencrx:kernel:generic:CrxObject:disabled",
1651      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1652      operator,
1653      values
1654    );
1655  }
1656
1657  public void forAllDisabled (
1658    short operator,
1659    boolean[] filterValues
1660  ) {
1661    java.util.List   arrayAsList = new java.util.ArrayList  ();
1662    for(int i = 0; i < filterValues.length; i++) {
1663      arrayAsList.add(
1664        new Boolean  (filterValues[i])
1665      );
1666    }
1667    forAllDisabled (
1668      operator,
1669      arrayAsList
1670    );
1671  }
1672
1673  public void thereExistsDisabled (
1674    short operator,
1675    boolean[] filterValues
1676  ) {
1677    java.util.List   arrayAsList = new java.util.ArrayList  ();
1678    for(int i = 0; i < filterValues.length; i++) {
1679      arrayAsList.add(
1680        new Boolean  (filterValues[i])
1681      );
1682    }
1683    thereExistsDisabled (
1684      operator,
1685      arrayAsList
1686    );
1687  }
1688
1689  public void orderByDisabled (
1690    short order
1691  ) {
1692    refAddValue(
1693      "org:opencrx:kernel:generic:CrxObject:disabled",
1694      order
1695    );
1696  }
1697      
1698// ----------------------------------------------------------------------------
1699// Filter/ImplAttributeIsNotStruct
1700// ----------------------------------------------------------------------------
1701  public void forAllDisabledReason (
1702    short operator,
1703    java.util.Collection   values
1704  ) {
1705    refAddValue(
1706      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1707      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1708      operator,
1709      values
1710    );
1711  }
1712
1713  public void thereExistsDisabledReason (
1714    short operator,
1715    java.util.Collection   values
1716  ) {
1717    refAddValue(
1718      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1719      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1720      operator,
1721      values
1722    );
1723  }
1724
1725  public void forAllDisabledReason (
1726    short operator,
1727    String  [] filterValues
1728  ) {
1729    java.util.List   arrayAsList = new java.util.ArrayList  ();
1730    for(int i = 0; i < filterValues.length; i++) {
1731      arrayAsList.add(
1732        filterValues[i]
1733      );
1734    }
1735    forAllDisabledReason (
1736      operator,
1737      arrayAsList
1738    );
1739  }
1740
1741  public void thereExistsDisabledReason (
1742    short operator,
1743    String  [] filterValues
1744  ) {
1745    java.util.List   arrayAsList = new java.util.ArrayList  ();
1746    for(int i = 0; i < filterValues.length; i++) {
1747      arrayAsList.add(
1748        filterValues[i]
1749      );
1750    }
1751    thereExistsDisabledReason (
1752      operator,
1753      arrayAsList
1754    );
1755  }
1756
1757  public void orderByDisabledReason (
1758    short order
1759  ) {
1760    refAddValue(
1761      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1762      order
1763    );
1764  }
1765      
1766// ----------------------------------------------------------------------------
1767// Filter/ImplAttributeIsNotStruct
1768// ----------------------------------------------------------------------------
1769  public void forAllExternalLink (
1770    short operator,
1771    java.util.Collection   values
1772  ) {
1773    refAddValue(
1774      "org:opencrx:kernel:generic:CrxObject:externalLink",
1775      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1776      operator,
1777      values
1778    );
1779  }
1780
1781  public void thereExistsExternalLink (
1782    short operator,
1783    java.util.Collection   values
1784  ) {
1785    refAddValue(
1786      "org:opencrx:kernel:generic:CrxObject:externalLink",
1787      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1788      operator,
1789      values
1790    );
1791  }
1792
1793  public void forAllExternalLink (
1794    short operator,
1795    String  [] filterValues
1796  ) {
1797    java.util.List   arrayAsList = new java.util.ArrayList  ();
1798    for(int i = 0; i < filterValues.length; i++) {
1799      arrayAsList.add(
1800        filterValues[i]
1801      );
1802    }
1803    forAllExternalLink (
1804      operator,
1805      arrayAsList
1806    );
1807  }
1808
1809  public void thereExistsExternalLink (
1810    short operator,
1811    String  [] filterValues
1812  ) {
1813    java.util.List   arrayAsList = new java.util.ArrayList  ();
1814    for(int i = 0; i < filterValues.length; i++) {
1815      arrayAsList.add(
1816        filterValues[i]
1817      );
1818    }
1819    thereExistsExternalLink (
1820      operator,
1821      arrayAsList
1822    );
1823  }
1824
1825  public void orderByExternalLink (
1826    short order
1827  ) {
1828    refAddValue(
1829      "org:opencrx:kernel:generic:CrxObject:externalLink",
1830      order
1831    );
1832  }
1833      
1834// ----------------------------------------------------------------------------
1835// Filter/ImplAttributeIsNotStruct
1836// ----------------------------------------------------------------------------
1837  public void forAllUserBoolean0 (
1838    short operator,
1839    java.util.Collection   values
1840  ) {
1841    refAddValue(
1842      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1843      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1844      operator,
1845      values
1846    );
1847  }
1848
1849  public void thereExistsUserBoolean0 (
1850    short operator,
1851    java.util.Collection   values
1852  ) {
1853    refAddValue(
1854      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1855      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1856      operator,
1857      values
1858    );
1859  }
1860
1861  public void forAllUserBoolean0 (
1862    short operator,
1863    boolean[] filterValues
1864  ) {
1865    java.util.List   arrayAsList = new java.util.ArrayList  ();
1866    for(int i = 0; i < filterValues.length; i++) {
1867      arrayAsList.add(
1868        new Boolean  (filterValues[i])
1869      );
1870    }
1871    forAllUserBoolean0 (
1872      operator,
1873      arrayAsList
1874    );
1875  }
1876
1877  public void thereExistsUserBoolean0 (
1878    short operator,
1879    boolean[] filterValues
1880  ) {
1881    java.util.List   arrayAsList = new java.util.ArrayList  ();
1882    for(int i = 0; i < filterValues.length; i++) {
1883      arrayAsList.add(
1884        new Boolean  (filterValues[i])
1885      );
1886    }
1887    thereExistsUserBoolean0 (
1888      operator,
1889      arrayAsList
1890    );
1891  }
1892
1893  public void orderByUserBoolean0 (
1894    short order
1895  ) {
1896    refAddValue(
1897      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1898      order
1899    );
1900  }
1901      
1902// ----------------------------------------------------------------------------
1903// Filter/ImplAttributeIsNotStruct
1904// ----------------------------------------------------------------------------
1905  public void forAllUserBoolean1 (
1906    short operator,
1907    java.util.Collection   values
1908  ) {
1909    refAddValue(
1910      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1911      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1912      operator,
1913      values
1914    );
1915  }
1916
1917  public void thereExistsUserBoolean1 (
1918    short operator,
1919    java.util.Collection   values
1920  ) {
1921    refAddValue(
1922      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1923      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1924      operator,
1925      values
1926    );
1927  }
1928
1929  public void forAllUserBoolean1 (
1930    short operator,
1931    boolean[] filterValues
1932  ) {
1933    java.util.List   arrayAsList = new java.util.ArrayList  ();
1934    for(int i = 0; i < filterValues.length; i++) {
1935      arrayAsList.add(
1936        new Boolean  (filterValues[i])
1937      );
1938    }
1939    forAllUserBoolean1 (
1940      operator,
1941      arrayAsList
1942    );
1943  }
1944
1945  public void thereExistsUserBoolean1 (
1946    short operator,
1947    boolean[] filterValues
1948  ) {
1949    java.util.List   arrayAsList = new java.util.ArrayList  ();
1950    for(int i = 0; i < filterValues.length; i++) {
1951      arrayAsList.add(
1952        new Boolean  (filterValues[i])
1953      );
1954    }
1955    thereExistsUserBoolean1 (
1956      operator,
1957      arrayAsList
1958    );
1959  }
1960
1961  public void orderByUserBoolean1 (
1962    short order
1963  ) {
1964    refAddValue(
1965      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1966      order
1967    );
1968  }
1969      
1970// ----------------------------------------------------------------------------
1971// Filter/ImplAttributeIsNotStruct
1972// ----------------------------------------------------------------------------
1973  public void forAllUserBoolean2 (
1974    short operator,
1975    java.util.Collection   values
1976  ) {
1977    refAddValue(
1978      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1979      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1980      operator,
1981      values
1982    );
1983  }
1984
1985  public void thereExistsUserBoolean2 (
1986    short operator,
1987    java.util.Collection   values
1988  ) {
1989    refAddValue(
1990      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1991      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1992      operator,
1993      values
1994    );
1995  }
1996
1997  public void forAllUserBoolean2 (
1998    short operator,
1999    boolean[] filterValues
2000  ) {
2001    java.util.List   arrayAsList = new java.util.ArrayList  ();
2002    for(int i = 0; i < filterValues.length; i++) {
2003      arrayAsList.add(
2004        new Boolean  (filterValues[i])
2005      );
2006    }
2007    forAllUserBoolean2 (
2008      operator,
2009      arrayAsList
2010    );
2011  }
2012
2013  public void thereExistsUserBoolean2 (
2014    short operator,
2015    boolean[] filterValues
2016  ) {
2017    java.util.List   arrayAsList = new java.util.ArrayList  ();
2018    for(int i = 0; i < filterValues.length; i++) {
2019      arrayAsList.add(
2020        new Boolean  (filterValues[i])
2021      );
2022    }
2023    thereExistsUserBoolean2 (
2024      operator,
2025      arrayAsList
2026    );
2027  }
2028
2029  public void orderByUserBoolean2 (
2030    short order
2031  ) {
2032    refAddValue(
2033      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
2034      order
2035    );
2036  }
2037      
2038// ----------------------------------------------------------------------------
2039// Filter/ImplAttributeIsNotStruct
2040// ----------------------------------------------------------------------------
2041  public void forAllUserBoolean3 (
2042    short operator,
2043    java.util.Collection   values
2044  ) {
2045    refAddValue(
2046      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2047      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2048      operator,
2049      values
2050    );
2051  }
2052
2053  public void thereExistsUserBoolean3 (
2054    short operator,
2055    java.util.Collection   values
2056  ) {
2057    refAddValue(
2058      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2059      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2060      operator,
2061      values
2062    );
2063  }
2064
2065  public void forAllUserBoolean3 (
2066    short operator,
2067    boolean[] filterValues
2068  ) {
2069    java.util.List   arrayAsList = new java.util.ArrayList  ();
2070    for(int i = 0; i < filterValues.length; i++) {
2071      arrayAsList.add(
2072        new Boolean  (filterValues[i])
2073      );
2074    }
2075    forAllUserBoolean3 (
2076      operator,
2077      arrayAsList
2078    );
2079  }
2080
2081  public void thereExistsUserBoolean3 (
2082    short operator,
2083    boolean[] filterValues
2084  ) {
2085    java.util.List   arrayAsList = new java.util.ArrayList  ();
2086    for(int i = 0; i < filterValues.length; i++) {
2087      arrayAsList.add(
2088        new Boolean  (filterValues[i])
2089      );
2090    }
2091    thereExistsUserBoolean3 (
2092      operator,
2093      arrayAsList
2094    );
2095  }
2096
2097  public void orderByUserBoolean3 (
2098    short order
2099  ) {
2100    refAddValue(
2101      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
2102      order
2103    );
2104  }
2105      
2106// ----------------------------------------------------------------------------
2107// Filter/ImplAttributeIsNotStruct
2108// ----------------------------------------------------------------------------
2109  public void forAllUserBoolean4 (
2110    short operator,
2111    java.util.Collection   values
2112  ) {
2113    refAddValue(
2114      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2115      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2116      operator,
2117      values
2118    );
2119  }
2120
2121  public void thereExistsUserBoolean4 (
2122    short operator,
2123    java.util.Collection   values
2124  ) {
2125    refAddValue(
2126      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2127      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2128      operator,
2129      values
2130    );
2131  }
2132
2133  public void forAllUserBoolean4 (
2134    short operator,
2135    boolean[] filterValues
2136  ) {
2137    java.util.List   arrayAsList = new java.util.ArrayList  ();
2138    for(int i = 0; i < filterValues.length; i++) {
2139      arrayAsList.add(
2140        new Boolean  (filterValues[i])
2141      );
2142    }
2143    forAllUserBoolean4 (
2144      operator,
2145      arrayAsList
2146    );
2147  }
2148
2149  public void thereExistsUserBoolean4 (
2150    short operator,
2151    boolean[] filterValues
2152  ) {
2153    java.util.List   arrayAsList = new java.util.ArrayList  ();
2154    for(int i = 0; i < filterValues.length; i++) {
2155      arrayAsList.add(
2156        new Boolean  (filterValues[i])
2157      );
2158    }
2159    thereExistsUserBoolean4 (
2160      operator,
2161      arrayAsList
2162    );
2163  }
2164
2165  public void orderByUserBoolean4 (
2166    short order
2167  ) {
2168    refAddValue(
2169      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
2170      order
2171    );
2172  }
2173      
2174// ----------------------------------------------------------------------------
2175// Filter/ImplAttributeIsNotStruct
2176// ----------------------------------------------------------------------------
2177  public void forAllUserCode0 (
2178    short operator,
2179    java.util.Collection   values
2180  ) {
2181    refAddValue(
2182      "org:opencrx:kernel:generic:CrxObject:userCode0",
2183      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2184      operator,
2185      values
2186    );
2187  }
2188
2189  public void thereExistsUserCode0 (
2190    short operator,
2191    java.util.Collection   values
2192  ) {
2193    refAddValue(
2194      "org:opencrx:kernel:generic:CrxObject:userCode0",
2195      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2196      operator,
2197      values
2198    );
2199  }
2200
2201  public void forAllUserCode0 (
2202    short operator,
2203    short[] filterValues
2204  ) {
2205    java.util.List   arrayAsList = new java.util.ArrayList  ();
2206    for(int i = 0; i < filterValues.length; i++) {
2207      arrayAsList.add(
2208        new Short  (filterValues[i])
2209      );
2210    }
2211    forAllUserCode0 (
2212      operator,
2213      arrayAsList
2214    );
2215  }
2216
2217  public void thereExistsUserCode0 (
2218    short operator,
2219    short[] filterValues
2220  ) {
2221    java.util.List   arrayAsList = new java.util.ArrayList  ();
2222    for(int i = 0; i < filterValues.length; i++) {
2223      arrayAsList.add(
2224        new Short  (filterValues[i])
2225      );
2226    }
2227    thereExistsUserCode0 (
2228      operator,
2229      arrayAsList
2230    );
2231  }
2232
2233  public void orderByUserCode0 (
2234    short order
2235  ) {
2236    refAddValue(
2237      "org:opencrx:kernel:generic:CrxObject:userCode0",
2238      order
2239    );
2240  }
2241      
2242// ----------------------------------------------------------------------------
2243// Filter/ImplAttributeIsNotStruct
2244// ----------------------------------------------------------------------------
2245  public void forAllUserCode1 (
2246    short operator,
2247    java.util.Collection   values
2248  ) {
2249    refAddValue(
2250      "org:opencrx:kernel:generic:CrxObject:userCode1",
2251      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2252      operator,
2253      values
2254    );
2255  }
2256
2257  public void thereExistsUserCode1 (
2258    short operator,
2259    java.util.Collection   values
2260  ) {
2261    refAddValue(
2262      "org:opencrx:kernel:generic:CrxObject:userCode1",
2263      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2264      operator,
2265      values
2266    );
2267  }
2268
2269  public void forAllUserCode1 (
2270    short operator,
2271    short[] filterValues
2272  ) {
2273    java.util.List   arrayAsList = new java.util.ArrayList  ();
2274    for(int i = 0; i < filterValues.length; i++) {
2275      arrayAsList.add(
2276        new Short  (filterValues[i])
2277      );
2278    }
2279    forAllUserCode1 (
2280      operator,
2281      arrayAsList
2282    );
2283  }
2284
2285  public void thereExistsUserCode1 (
2286    short operator,
2287    short[] filterValues
2288  ) {
2289    java.util.List   arrayAsList = new java.util.ArrayList  ();
2290    for(int i = 0; i < filterValues.length; i++) {
2291      arrayAsList.add(
2292        new Short  (filterValues[i])
2293      );
2294    }
2295    thereExistsUserCode1 (
2296      operator,
2297      arrayAsList
2298    );
2299  }
2300
2301  public void orderByUserCode1 (
2302    short order
2303  ) {
2304    refAddValue(
2305      "org:opencrx:kernel:generic:CrxObject:userCode1",
2306      order
2307    );
2308  }
2309      
2310// ----------------------------------------------------------------------------
2311// Filter/ImplAttributeIsNotStruct
2312// ----------------------------------------------------------------------------
2313  public void forAllUserCode2 (
2314    short operator,
2315    java.util.Collection   values
2316  ) {
2317    refAddValue(
2318      "org:opencrx:kernel:generic:CrxObject:userCode2",
2319      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2320      operator,
2321      values
2322    );
2323  }
2324
2325  public void thereExistsUserCode2 (
2326    short operator,
2327    java.util.Collection   values
2328  ) {
2329    refAddValue(
2330      "org:opencrx:kernel:generic:CrxObject:userCode2",
2331      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2332      operator,
2333      values
2334    );
2335  }
2336
2337  public void forAllUserCode2 (
2338    short operator,
2339    short[] filterValues
2340  ) {
2341    java.util.List   arrayAsList = new java.util.ArrayList  ();
2342    for(int i = 0; i < filterValues.length; i++) {
2343      arrayAsList.add(
2344        new Short  (filterValues[i])
2345      );
2346    }
2347    forAllUserCode2 (
2348      operator,
2349      arrayAsList
2350    );
2351  }
2352
2353  public void thereExistsUserCode2 (
2354    short operator,
2355    short[] filterValues
2356  ) {
2357    java.util.List   arrayAsList = new java.util.ArrayList  ();
2358    for(int i = 0; i < filterValues.length; i++) {
2359      arrayAsList.add(
2360        new Short  (filterValues[i])
2361      );
2362    }
2363    thereExistsUserCode2 (
2364      operator,
2365      arrayAsList
2366    );
2367  }
2368
2369  public void orderByUserCode2 (
2370    short order
2371  ) {
2372    refAddValue(
2373      "org:opencrx:kernel:generic:CrxObject:userCode2",
2374      order
2375    );
2376  }
2377      
2378// ----------------------------------------------------------------------------
2379// Filter/ImplAttributeIsNotStruct
2380// ----------------------------------------------------------------------------
2381  public void forAllUserCode3 (
2382    short operator,
2383    java.util.Collection   values
2384  ) {
2385    refAddValue(
2386      "org:opencrx:kernel:generic:CrxObject:userCode3",
2387      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2388      operator,
2389      values
2390    );
2391  }
2392
2393  public void thereExistsUserCode3 (
2394    short operator,
2395    java.util.Collection   values
2396  ) {
2397    refAddValue(
2398      "org:opencrx:kernel:generic:CrxObject:userCode3",
2399      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2400      operator,
2401      values
2402    );
2403  }
2404
2405  public void forAllUserCode3 (
2406    short operator,
2407    short[] filterValues
2408  ) {
2409    java.util.List   arrayAsList = new java.util.ArrayList  ();
2410    for(int i = 0; i < filterValues.length; i++) {
2411      arrayAsList.add(
2412        new Short  (filterValues[i])
2413      );
2414    }
2415    forAllUserCode3 (
2416      operator,
2417      arrayAsList
2418    );
2419  }
2420
2421  public void thereExistsUserCode3 (
2422    short operator,
2423    short[] filterValues
2424  ) {
2425    java.util.List   arrayAsList = new java.util.ArrayList  ();
2426    for(int i = 0; i < filterValues.length; i++) {
2427      arrayAsList.add(
2428        new Short  (filterValues[i])
2429      );
2430    }
2431    thereExistsUserCode3 (
2432      operator,
2433      arrayAsList
2434    );
2435  }
2436
2437  public void orderByUserCode3 (
2438    short order
2439  ) {
2440    refAddValue(
2441      "org:opencrx:kernel:generic:CrxObject:userCode3",
2442      order
2443    );
2444  }
2445      
2446// ----------------------------------------------------------------------------
2447// Filter/ImplAttributeIsNotStruct
2448// ----------------------------------------------------------------------------
2449  public void forAllUserCode4 (
2450    short operator,
2451    java.util.Collection   values
2452  ) {
2453    refAddValue(
2454      "org:opencrx:kernel:generic:CrxObject:userCode4",
2455      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2456      operator,
2457      values
2458    );
2459  }
2460
2461  public void thereExistsUserCode4 (
2462    short operator,
2463    java.util.Collection   values
2464  ) {
2465    refAddValue(
2466      "org:opencrx:kernel:generic:CrxObject:userCode4",
2467      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2468      operator,
2469      values
2470    );
2471  }
2472
2473  public void forAllUserCode4 (
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    forAllUserCode4 (
2484      operator,
2485      arrayAsList
2486    );
2487  }
2488
2489  public void thereExistsUserCode4 (
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    thereExistsUserCode4 (
2500      operator,
2501      arrayAsList
2502    );
2503  }
2504
2505  public void orderByUserCode4 (
2506    short order
2507  ) {
2508    refAddValue(
2509      "org:opencrx:kernel:generic:CrxObject:userCode4",
2510      order
2511    );
2512  }
2513      
2514// ----------------------------------------------------------------------------
2515// Filter/ImplAttributeIsNotStruct
2516// ----------------------------------------------------------------------------
2517  public void forAllUserDate0 (
2518    short operator,
2519    java.util.Collection   values
2520  ) {
2521    refAddValue(
2522      "org:opencrx:kernel:generic:CrxObject:userDate0",
2523      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2524      operator,
2525      values
2526    );
2527  }
2528
2529  public void thereExistsUserDate0 (
2530    short operator,
2531    java.util.Collection   values
2532  ) {
2533    refAddValue(
2534      "org:opencrx:kernel:generic:CrxObject:userDate0",
2535      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2536      operator,
2537      values
2538    );
2539  }
2540
2541  public void forAllUserDate0 (
2542    short operator,
2543    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2544  ) {
2545    java.util.List   arrayAsList = new java.util.ArrayList  ();
2546    for(int i = 0; i < filterValues.length; i++) {
2547      arrayAsList.add(
2548        filterValues[i]
2549      );
2550    }
2551    forAllUserDate0 (
2552      operator,
2553      arrayAsList
2554    );
2555  }
2556
2557  public void thereExistsUserDate0 (
2558    short operator,
2559    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2560  ) {
2561    java.util.List   arrayAsList = new java.util.ArrayList  ();
2562    for(int i = 0; i < filterValues.length; i++) {
2563      arrayAsList.add(
2564        filterValues[i]
2565      );
2566    }
2567    thereExistsUserDate0 (
2568      operator,
2569      arrayAsList
2570    );
2571  }
2572
2573  public void orderByUserDate0 (
2574    short order
2575  ) {
2576    refAddValue(
2577      "org:opencrx:kernel:generic:CrxObject:userDate0",
2578      order
2579    );
2580  }
2581      
2582// ----------------------------------------------------------------------------
2583// Filter/ImplAttributeIsNotStruct
2584// ----------------------------------------------------------------------------
2585  public void forAllUserDate1 (
2586    short operator,
2587    java.util.Collection   values
2588  ) {
2589    refAddValue(
2590      "org:opencrx:kernel:generic:CrxObject:userDate1",
2591      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2592      operator,
2593      values
2594    );
2595  }
2596
2597  public void thereExistsUserDate1 (
2598    short operator,
2599    java.util.Collection   values
2600  ) {
2601    refAddValue(
2602      "org:opencrx:kernel:generic:CrxObject:userDate1",
2603      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2604      operator,
2605      values
2606    );
2607  }
2608
2609  public void forAllUserDate1 (
2610    short operator,
2611    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2612  ) {
2613    java.util.List   arrayAsList = new java.util.ArrayList  ();
2614    for(int i = 0; i < filterValues.length; i++) {
2615      arrayAsList.add(
2616        filterValues[i]
2617      );
2618    }
2619    forAllUserDate1 (
2620      operator,
2621      arrayAsList
2622    );
2623  }
2624
2625  public void thereExistsUserDate1 (
2626    short operator,
2627    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2628  ) {
2629    java.util.List   arrayAsList = new java.util.ArrayList  ();
2630    for(int i = 0; i < filterValues.length; i++) {
2631      arrayAsList.add(
2632        filterValues[i]
2633      );
2634    }
2635    thereExistsUserDate1 (
2636      operator,
2637      arrayAsList
2638    );
2639  }
2640
2641  public void orderByUserDate1 (
2642    short order
2643  ) {
2644    refAddValue(
2645      "org:opencrx:kernel:generic:CrxObject:userDate1",
2646      order
2647    );
2648  }
2649      
2650// ----------------------------------------------------------------------------
2651// Filter/ImplAttributeIsNotStruct
2652// ----------------------------------------------------------------------------
2653  public void forAllUserDate2 (
2654    short operator,
2655    java.util.Collection   values
2656  ) {
2657    refAddValue(
2658      "org:opencrx:kernel:generic:CrxObject:userDate2",
2659      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2660      operator,
2661      values
2662    );
2663  }
2664
2665  public void thereExistsUserDate2 (
2666    short operator,
2667    java.util.Collection   values
2668  ) {
2669    refAddValue(
2670      "org:opencrx:kernel:generic:CrxObject:userDate2",
2671      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2672      operator,
2673      values
2674    );
2675  }
2676
2677  public void forAllUserDate2 (
2678    short operator,
2679    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2680  ) {
2681    java.util.List   arrayAsList = new java.util.ArrayList  ();
2682    for(int i = 0; i < filterValues.length; i++) {
2683      arrayAsList.add(
2684        filterValues[i]
2685      );
2686    }
2687    forAllUserDate2 (
2688      operator,
2689      arrayAsList
2690    );
2691  }
2692
2693  public void thereExistsUserDate2 (
2694    short operator,
2695    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2696  ) {
2697    java.util.List   arrayAsList = new java.util.ArrayList  ();
2698    for(int i = 0; i < filterValues.length; i++) {
2699      arrayAsList.add(
2700        filterValues[i]
2701      );
2702    }
2703    thereExistsUserDate2 (
2704      operator,
2705      arrayAsList
2706    );
2707  }
2708
2709  public void orderByUserDate2 (
2710    short order
2711  ) {
2712    refAddValue(
2713      "org:opencrx:kernel:generic:CrxObject:userDate2",
2714      order
2715    );
2716  }
2717      
2718// ----------------------------------------------------------------------------
2719// Filter/ImplAttributeIsNotStruct
2720// ----------------------------------------------------------------------------
2721  public void forAllUserDate3 (
2722    short operator,
2723    java.util.Collection   values
2724  ) {
2725    refAddValue(
2726      "org:opencrx:kernel:generic:CrxObject:userDate3",
2727      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2728      operator,
2729      values
2730    );
2731  }
2732
2733  public void thereExistsUserDate3 (
2734    short operator,
2735    java.util.Collection   values
2736  ) {
2737    refAddValue(
2738      "org:opencrx:kernel:generic:CrxObject:userDate3",
2739      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2740      operator,
2741      values
2742    );
2743  }
2744
2745  public void forAllUserDate3 (
2746    short operator,
2747    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2748  ) {
2749    java.util.List   arrayAsList = new java.util.ArrayList  ();
2750    for(int i = 0; i < filterValues.length; i++) {
2751      arrayAsList.add(
2752        filterValues[i]
2753      );
2754    }
2755    forAllUserDate3 (
2756      operator,
2757      arrayAsList
2758    );
2759  }
2760
2761  public void thereExistsUserDate3 (
2762    short operator,
2763    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2764  ) {
2765    java.util.List   arrayAsList = new java.util.ArrayList  ();
2766    for(int i = 0; i < filterValues.length; i++) {
2767      arrayAsList.add(
2768        filterValues[i]
2769      );
2770    }
2771    thereExistsUserDate3 (
2772      operator,
2773      arrayAsList
2774    );
2775  }
2776
2777  public void orderByUserDate3 (
2778    short order
2779  ) {
2780    refAddValue(
2781      "org:opencrx:kernel:generic:CrxObject:userDate3",
2782      order
2783    );
2784  }
2785      
2786// ----------------------------------------------------------------------------
2787// Filter/ImplAttributeIsNotStruct
2788// ----------------------------------------------------------------------------
2789  public void forAllUserDate4 (
2790    short operator,
2791    java.util.Collection   values
2792  ) {
2793    refAddValue(
2794      "org:opencrx:kernel:generic:CrxObject:userDate4",
2795      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2796      operator,
2797      values
2798    );
2799  }
2800
2801  public void thereExistsUserDate4 (
2802    short operator,
2803    java.util.Collection   values
2804  ) {
2805    refAddValue(
2806      "org:opencrx:kernel:generic:CrxObject:userDate4",
2807      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2808      operator,
2809      values
2810    );
2811  }
2812
2813  public void forAllUserDate4 (
2814    short operator,
2815    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2816  ) {
2817    java.util.List   arrayAsList = new java.util.ArrayList  ();
2818    for(int i = 0; i < filterValues.length; i++) {
2819      arrayAsList.add(
2820        filterValues[i]
2821      );
2822    }
2823    forAllUserDate4 (
2824      operator,
2825      arrayAsList
2826    );
2827  }
2828
2829  public void thereExistsUserDate4 (
2830    short operator,
2831    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2832  ) {
2833    java.util.List   arrayAsList = new java.util.ArrayList  ();
2834    for(int i = 0; i < filterValues.length; i++) {
2835      arrayAsList.add(
2836        filterValues[i]
2837      );
2838    }
2839    thereExistsUserDate4 (
2840      operator,
2841      arrayAsList
2842    );
2843  }
2844
2845  public void orderByUserDate4 (
2846    short order
2847  ) {
2848    refAddValue(
2849      "org:opencrx:kernel:generic:CrxObject:userDate4",
2850      order
2851    );
2852  }
2853      
2854// ----------------------------------------------------------------------------
2855// Filter/ImplAttributeIsNotStruct
2856// ----------------------------------------------------------------------------
2857  public void forAllUserDateTime0 (
2858    short operator,
2859    java.util.Collection   values
2860  ) {
2861    refAddValue(
2862      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2863      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2864      operator,
2865      values
2866    );
2867  }
2868
2869  public void thereExistsUserDateTime0 (
2870    short operator,
2871    java.util.Collection   values
2872  ) {
2873    refAddValue(
2874      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2875      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2876      operator,
2877      values
2878    );
2879  }
2880
2881  public void forAllUserDateTime0 (
2882    short operator,
2883    java.util.Date  [] filterValues
2884  ) {
2885    java.util.List   arrayAsList = new java.util.ArrayList  ();
2886    for(int i = 0; i < filterValues.length; i++) {
2887      arrayAsList.add(
2888        filterValues[i]
2889      );
2890    }
2891    forAllUserDateTime0 (
2892      operator,
2893      arrayAsList
2894    );
2895  }
2896
2897  public void thereExistsUserDateTime0 (
2898    short operator,
2899    java.util.Date  [] filterValues
2900  ) {
2901    java.util.List   arrayAsList = new java.util.ArrayList  ();
2902    for(int i = 0; i < filterValues.length; i++) {
2903      arrayAsList.add(
2904        filterValues[i]
2905      );
2906    }
2907    thereExistsUserDateTime0 (
2908      operator,
2909      arrayAsList
2910    );
2911  }
2912
2913  public void orderByUserDateTime0 (
2914    short order
2915  ) {
2916    refAddValue(
2917      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2918      order
2919    );
2920  }
2921      
2922// ----------------------------------------------------------------------------
2923// Filter/ImplAttributeIsNotStruct
2924// ----------------------------------------------------------------------------
2925  public void forAllUserDateTime1 (
2926    short operator,
2927    java.util.Collection   values
2928  ) {
2929    refAddValue(
2930      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2931      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2932      operator,
2933      values
2934    );
2935  }
2936
2937  public void thereExistsUserDateTime1 (
2938    short operator,
2939    java.util.Collection   values
2940  ) {
2941    refAddValue(
2942      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2943      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2944      operator,
2945      values
2946    );
2947  }
2948
2949  public void forAllUserDateTime1 (
2950    short operator,
2951    java.util.Date  [] filterValues
2952  ) {
2953    java.util.List   arrayAsList = new java.util.ArrayList  ();
2954    for(int i = 0; i < filterValues.length; i++) {
2955      arrayAsList.add(
2956        filterValues[i]
2957      );
2958    }
2959    forAllUserDateTime1 (
2960      operator,
2961      arrayAsList
2962    );
2963  }
2964
2965  public void thereExistsUserDateTime1 (
2966    short operator,
2967    java.util.Date  [] filterValues
2968  ) {
2969    java.util.List   arrayAsList = new java.util.ArrayList  ();
2970    for(int i = 0; i < filterValues.length; i++) {
2971      arrayAsList.add(
2972        filterValues[i]
2973      );
2974    }
2975    thereExistsUserDateTime1 (
2976      operator,
2977      arrayAsList
2978    );
2979  }
2980
2981  public void orderByUserDateTime1 (
2982    short order
2983  ) {
2984    refAddValue(
2985      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2986      order
2987    );
2988  }
2989      
2990// ----------------------------------------------------------------------------
2991// Filter/ImplAttributeIsNotStruct
2992// ----------------------------------------------------------------------------
2993  public void forAllUserDateTime2 (
2994    short operator,
2995    java.util.Collection   values
2996  ) {
2997    refAddValue(
2998      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2999      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3000      operator,
3001      values
3002    );
3003  }
3004
3005  public void thereExistsUserDateTime2 (
3006    short operator,
3007    java.util.Collection   values
3008  ) {
3009    refAddValue(
3010      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3011      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3012      operator,
3013      values
3014    );
3015  }
3016
3017  public void forAllUserDateTime2 (
3018    short operator,
3019    java.util.Date  [] filterValues
3020  ) {
3021    java.util.List   arrayAsList = new java.util.ArrayList  ();
3022    for(int i = 0; i < filterValues.length; i++) {
3023      arrayAsList.add(
3024        filterValues[i]
3025      );
3026    }
3027    forAllUserDateTime2 (
3028      operator,
3029      arrayAsList
3030    );
3031  }
3032
3033  public void thereExistsUserDateTime2 (
3034    short operator,
3035    java.util.Date  [] filterValues
3036  ) {
3037    java.util.List   arrayAsList = new java.util.ArrayList  ();
3038    for(int i = 0; i < filterValues.length; i++) {
3039      arrayAsList.add(
3040        filterValues[i]
3041      );
3042    }
3043    thereExistsUserDateTime2 (
3044      operator,
3045      arrayAsList
3046    );
3047  }
3048
3049  public void orderByUserDateTime2 (
3050    short order
3051  ) {
3052    refAddValue(
3053      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
3054      order
3055    );
3056  }
3057      
3058// ----------------------------------------------------------------------------
3059// Filter/ImplAttributeIsNotStruct
3060// ----------------------------------------------------------------------------
3061  public void forAllUserDateTime3 (
3062    short operator,
3063    java.util.Collection   values
3064  ) {
3065    refAddValue(
3066      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3067      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3068      operator,
3069      values
3070    );
3071  }
3072
3073  public void thereExistsUserDateTime3 (
3074    short operator,
3075    java.util.Collection   values
3076  ) {
3077    refAddValue(
3078      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3079      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3080      operator,
3081      values
3082    );
3083  }
3084
3085  public void forAllUserDateTime3 (
3086    short operator,
3087    java.util.Date  [] filterValues
3088  ) {
3089    java.util.List   arrayAsList = new java.util.ArrayList  ();
3090    for(int i = 0; i < filterValues.length; i++) {
3091      arrayAsList.add(
3092        filterValues[i]
3093      );
3094    }
3095    forAllUserDateTime3 (
3096      operator,
3097      arrayAsList
3098    );
3099  }
3100
3101  public void thereExistsUserDateTime3 (
3102    short operator,
3103    java.util.Date  [] filterValues
3104  ) {
3105    java.util.List   arrayAsList = new java.util.ArrayList  ();
3106    for(int i = 0; i < filterValues.length; i++) {
3107      arrayAsList.add(
3108        filterValues[i]
3109      );
3110    }
3111    thereExistsUserDateTime3 (
3112      operator,
3113      arrayAsList
3114    );
3115  }
3116
3117  public void orderByUserDateTime3 (
3118    short order
3119  ) {
3120    refAddValue(
3121      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
3122      order
3123    );
3124  }
3125      
3126// ----------------------------------------------------------------------------
3127// Filter/ImplAttributeIsNotStruct
3128// ----------------------------------------------------------------------------
3129  public void forAllUserDateTime4 (
3130    short operator,
3131    java.util.Collection   values
3132  ) {
3133    refAddValue(
3134      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3135      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3136      operator,
3137      values
3138    );
3139  }
3140
3141  public void thereExistsUserDateTime4 (
3142    short operator,
3143    java.util.Collection   values
3144  ) {
3145    refAddValue(
3146      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3147      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3148      operator,
3149      values
3150    );
3151  }
3152
3153  public void forAllUserDateTime4 (
3154    short operator,
3155    java.util.Date  [] filterValues
3156  ) {
3157    java.util.List   arrayAsList = new java.util.ArrayList  ();
3158    for(int i = 0; i < filterValues.length; i++) {
3159      arrayAsList.add(
3160        filterValues[i]
3161      );
3162    }
3163    forAllUserDateTime4 (
3164      operator,
3165      arrayAsList
3166    );
3167  }
3168
3169  public void thereExistsUserDateTime4 (
3170    short operator,
3171    java.util.Date  [] filterValues
3172  ) {
3173    java.util.List   arrayAsList = new java.util.ArrayList  ();
3174    for(int i = 0; i < filterValues.length; i++) {
3175      arrayAsList.add(
3176        filterValues[i]
3177      );
3178    }
3179    thereExistsUserDateTime4 (
3180      operator,
3181      arrayAsList
3182    );
3183  }
3184
3185  public void orderByUserDateTime4 (
3186    short order
3187  ) {
3188    refAddValue(
3189      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
3190      order
3191    );
3192  }
3193      
3194// ----------------------------------------------------------------------------
3195// Filter/ImplAttributeIsNotStruct
3196// ----------------------------------------------------------------------------
3197  public void forAllUserNumber0 (
3198    short operator,
3199    java.util.Collection   values
3200  ) {
3201    refAddValue(
3202      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3203      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3204      operator,
3205      values
3206    );
3207  }
3208
3209  public void thereExistsUserNumber0 (
3210    short operator,
3211    java.util.Collection   values
3212  ) {
3213    refAddValue(
3214      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3215      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3216      operator,
3217      values
3218    );
3219  }
3220
3221  public void forAllUserNumber0 (
3222    short operator,
3223    java.math.BigDecimal  [] filterValues
3224  ) {
3225    java.util.List   arrayAsList = new java.util.ArrayList  ();
3226    for(int i = 0; i < filterValues.length; i++) {
3227      arrayAsList.add(
3228        filterValues[i]
3229      );
3230    }
3231    forAllUserNumber0 (
3232      operator,
3233      arrayAsList
3234    );
3235  }
3236
3237  public void thereExistsUserNumber0 (
3238    short operator,
3239    java.math.BigDecimal  [] filterValues
3240  ) {
3241    java.util.List   arrayAsList = new java.util.ArrayList  ();
3242    for(int i = 0; i < filterValues.length; i++) {
3243      arrayAsList.add(
3244        filterValues[i]
3245      );
3246    }
3247    thereExistsUserNumber0 (
3248      operator,
3249      arrayAsList
3250    );
3251  }
3252
3253  public void orderByUserNumber0 (
3254    short order
3255  ) {
3256    refAddValue(
3257      "org:opencrx:kernel:generic:CrxObject:userNumber0",
3258      order
3259    );
3260  }
3261      
3262// ----------------------------------------------------------------------------
3263// Filter/ImplAttributeIsNotStruct
3264// ----------------------------------------------------------------------------
3265  public void forAllUserNumber1 (
3266    short operator,
3267    java.util.Collection   values
3268  ) {
3269    refAddValue(
3270      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3271      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3272      operator,
3273      values
3274    );
3275  }
3276
3277  public void thereExistsUserNumber1 (
3278    short operator,
3279    java.util.Collection   values
3280  ) {
3281    refAddValue(
3282      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3283      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3284      operator,
3285      values
3286    );
3287  }
3288
3289  public void forAllUserNumber1 (
3290    short operator,
3291    java.math.BigDecimal  [] filterValues
3292  ) {
3293    java.util.List   arrayAsList = new java.util.ArrayList  ();
3294    for(int i = 0; i < filterValues.length; i++) {
3295      arrayAsList.add(
3296        filterValues[i]
3297      );
3298    }
3299    forAllUserNumber1 (
3300      operator,
3301      arrayAsList
3302    );
3303  }
3304
3305  public void thereExistsUserNumber1 (
3306    short operator,
3307    java.math.BigDecimal  [] filterValues
3308  ) {
3309    java.util.List   arrayAsList = new java.util.ArrayList  ();
3310    for(int i = 0; i < filterValues.length; i++) {
3311      arrayAsList.add(
3312        filterValues[i]
3313      );
3314    }
3315    thereExistsUserNumber1 (
3316      operator,
3317      arrayAsList
3318    );
3319  }
3320
3321  public void orderByUserNumber1 (
3322    short order
3323  ) {
3324    refAddValue(
3325      "org:opencrx:kernel:generic:CrxObject:userNumber1",
3326      order
3327    );
3328  }
3329      
3330// ----------------------------------------------------------------------------
3331// Filter/ImplAttributeIsNotStruct
3332// ----------------------------------------------------------------------------
3333  public void forAllUserNumber2 (
3334    short operator,
3335    java.util.Collection   values
3336  ) {
3337    refAddValue(
3338      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3339      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3340      operator,
3341      values
3342    );
3343  }
3344
3345  public void thereExistsUserNumber2 (
3346    short operator,
3347    java.util.Collection   values
3348  ) {
3349    refAddValue(
3350      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3351      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3352      operator,
3353      values
3354    );
3355  }
3356
3357  public void forAllUserNumber2 (
3358    short operator,
3359    java.math.BigDecimal  [] filterValues
3360  ) {
3361    java.util.List   arrayAsList = new java.util.ArrayList  ();
3362    for(int i = 0; i < filterValues.length; i++) {
3363      arrayAsList.add(
3364        filterValues[i]
3365      );
3366    }
3367    forAllUserNumber2 (
3368      operator,
3369      arrayAsList
3370    );
3371  }
3372
3373  public void thereExistsUserNumber2 (
3374    short operator,
3375    java.math.BigDecimal  [] filterValues
3376  ) {
3377    java.util.List   arrayAsList = new java.util.ArrayList  ();
3378    for(int i = 0; i < filterValues.length; i++) {
3379      arrayAsList.add(
3380        filterValues[i]
3381      );
3382    }
3383    thereExistsUserNumber2 (
3384      operator,
3385      arrayAsList
3386    );
3387  }
3388
3389  public void orderByUserNumber2 (
3390    short order
3391  ) {
3392    refAddValue(
3393      "org:opencrx:kernel:generic:CrxObject:userNumber2",
3394      order
3395    );
3396  }
3397      
3398// ----------------------------------------------------------------------------
3399// Filter/ImplAttributeIsNotStruct
3400// ----------------------------------------------------------------------------
3401  public void forAllUserNumber3 (
3402    short operator,
3403    java.util.Collection   values
3404  ) {
3405    refAddValue(
3406      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3407      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3408      operator,
3409      values
3410    );
3411  }
3412
3413  public void thereExistsUserNumber3 (
3414    short operator,
3415    java.util.Collection   values
3416  ) {
3417    refAddValue(
3418      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3419      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3420      operator,
3421      values
3422    );
3423  }
3424
3425  public void forAllUserNumber3 (
3426    short operator,
3427    java.math.BigDecimal  [] filterValues
3428  ) {
3429    java.util.List   arrayAsList = new java.util.ArrayList  ();
3430    for(int i = 0; i < filterValues.length; i++) {
3431      arrayAsList.add(
3432        filterValues[i]
3433      );
3434    }
3435    forAllUserNumber3 (
3436      operator,
3437      arrayAsList
3438    );
3439  }
3440
3441  public void thereExistsUserNumber3 (
3442    short operator,
3443    java.math.BigDecimal  [] filterValues
3444  ) {
3445    java.util.List   arrayAsList = new java.util.ArrayList  ();
3446    for(int i = 0; i < filterValues.length; i++) {
3447      arrayAsList.add(
3448        filterValues[i]
3449      );
3450    }
3451    thereExistsUserNumber3 (
3452      operator,
3453      arrayAsList
3454    );
3455  }
3456
3457  public void orderByUserNumber3 (
3458    short order
3459  ) {
3460    refAddValue(
3461      "org:opencrx:kernel:generic:CrxObject:userNumber3",
3462      order
3463    );
3464  }
3465      
3466// ----------------------------------------------------------------------------
3467// Filter/ImplAttributeIsNotStruct
3468// ----------------------------------------------------------------------------
3469  public void forAllUserNumber4 (
3470    short operator,
3471    java.util.Collection   values
3472  ) {
3473    refAddValue(
3474      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3475      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3476      operator,
3477      values
3478    );
3479  }
3480
3481  public void thereExistsUserNumber4 (
3482    short operator,
3483    java.util.Collection   values
3484  ) {
3485    refAddValue(
3486      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3487      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3488      operator,
3489      values
3490    );
3491  }
3492
3493  public void forAllUserNumber4 (
3494    short operator,
3495    java.math.BigDecimal  [] filterValues
3496  ) {
3497    java.util.List   arrayAsList = new java.util.ArrayList  ();
3498    for(int i = 0; i < filterValues.length; i++) {
3499      arrayAsList.add(
3500        filterValues[i]
3501      );
3502    }
3503    forAllUserNumber4 (
3504      operator,
3505      arrayAsList
3506    );
3507  }
3508
3509  public void thereExistsUserNumber4 (
3510    short operator,
3511    java.math.BigDecimal  [] filterValues
3512  ) {
3513    java.util.List   arrayAsList = new java.util.ArrayList  ();
3514    for(int i = 0; i < filterValues.length; i++) {
3515      arrayAsList.add(
3516        filterValues[i]
3517      );
3518    }
3519    thereExistsUserNumber4 (
3520      operator,
3521      arrayAsList
3522    );
3523  }
3524
3525  public void orderByUserNumber4 (
3526    short order
3527  ) {
3528    refAddValue(
3529      "org:opencrx:kernel:generic:CrxObject:userNumber4",
3530      order
3531    );
3532  }
3533      
3534// ----------------------------------------------------------------------------
3535// Filter/ImplAttributeIsNotStruct
3536// ----------------------------------------------------------------------------
3537  public void forAllUserString0 (
3538    short operator,
3539    java.util.Collection   values
3540  ) {
3541    refAddValue(
3542      "org:opencrx:kernel:generic:CrxObject:userString0",
3543      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3544      operator,
3545      values
3546    );
3547  }
3548
3549  public void thereExistsUserString0 (
3550    short operator,
3551    java.util.Collection   values
3552  ) {
3553    refAddValue(
3554      "org:opencrx:kernel:generic:CrxObject:userString0",
3555      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3556      operator,
3557      values
3558    );
3559  }
3560
3561  public void forAllUserString0 (
3562    short operator,
3563    String  [] filterValues
3564  ) {
3565    java.util.List   arrayAsList = new java.util.ArrayList  ();
3566    for(int i = 0; i < filterValues.length; i++) {
3567      arrayAsList.add(
3568        filterValues[i]
3569      );
3570    }
3571    forAllUserString0 (
3572      operator,
3573      arrayAsList
3574    );
3575  }
3576
3577  public void thereExistsUserString0 (
3578    short operator,
3579    String  [] filterValues
3580  ) {
3581    java.util.List   arrayAsList = new java.util.ArrayList  ();
3582    for(int i = 0; i < filterValues.length; i++) {
3583      arrayAsList.add(
3584        filterValues[i]
3585      );
3586    }
3587    thereExistsUserString0 (
3588      operator,
3589      arrayAsList
3590    );
3591  }
3592
3593  public void orderByUserString0 (
3594    short order
3595  ) {
3596    refAddValue(
3597      "org:opencrx:kernel:generic:CrxObject:userString0",
3598      order
3599    );
3600  }
3601      
3602// ----------------------------------------------------------------------------
3603// Filter/ImplAttributeIsNotStruct
3604// ----------------------------------------------------------------------------
3605  public void forAllUserString1 (
3606    short operator,
3607    java.util.Collection   values
3608  ) {
3609    refAddValue(
3610      "org:opencrx:kernel:generic:CrxObject:userString1",
3611      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3612      operator,
3613      values
3614    );
3615  }
3616
3617  public void thereExistsUserString1 (
3618    short operator,
3619    java.util.Collection   values
3620  ) {
3621    refAddValue(
3622      "org:opencrx:kernel:generic:CrxObject:userString1",
3623      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3624      operator,
3625      values
3626    );
3627  }
3628
3629  public void forAllUserString1 (
3630    short operator,
3631    String  [] filterValues
3632  ) {
3633    java.util.List   arrayAsList = new java.util.ArrayList  ();
3634    for(int i = 0; i < filterValues.length; i++) {
3635      arrayAsList.add(
3636        filterValues[i]
3637      );
3638    }
3639    forAllUserString1 (
3640      operator,
3641      arrayAsList
3642    );
3643  }
3644
3645  public void thereExistsUserString1 (
3646    short operator,
3647    String  [] filterValues
3648  ) {
3649    java.util.List   arrayAsList = new java.util.ArrayList  ();
3650    for(int i = 0; i < filterValues.length; i++) {
3651      arrayAsList.add(
3652        filterValues[i]
3653      );
3654    }
3655    thereExistsUserString1 (
3656      operator,
3657      arrayAsList
3658    );
3659  }
3660
3661  public void orderByUserString1 (
3662    short order
3663  ) {
3664    refAddValue(
3665      "org:opencrx:kernel:generic:CrxObject:userString1",
3666      order
3667    );
3668  }
3669      
3670// ----------------------------------------------------------------------------
3671// Filter/ImplAttributeIsNotStruct
3672// ----------------------------------------------------------------------------
3673  public void forAllUserString2 (
3674    short operator,
3675    java.util.Collection   values
3676  ) {
3677    refAddValue(
3678      "org:opencrx:kernel:generic:CrxObject:userString2",
3679      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3680      operator,
3681      values
3682    );
3683  }
3684
3685  public void thereExistsUserString2 (
3686    short operator,
3687    java.util.Collection   values
3688  ) {
3689    refAddValue(
3690      "org:opencrx:kernel:generic:CrxObject:userString2",
3691      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3692      operator,
3693      values
3694    );
3695  }
3696
3697  public void forAllUserString2 (
3698    short operator,
3699    String  [] filterValues
3700  ) {
3701    java.util.List   arrayAsList = new java.util.ArrayList  ();
3702    for(int i = 0; i < filterValues.length; i++) {
3703      arrayAsList.add(
3704        filterValues[i]
3705      );
3706    }
3707    forAllUserString2 (
3708      operator,
3709      arrayAsList
3710    );
3711  }
3712
3713  public void thereExistsUserString2 (
3714    short operator,
3715    String  [] filterValues
3716  ) {
3717    java.util.List   arrayAsList = new java.util.ArrayList  ();
3718    for(int i = 0; i < filterValues.length; i++) {
3719      arrayAsList.add(
3720        filterValues[i]
3721      );
3722    }
3723    thereExistsUserString2 (
3724      operator,
3725      arrayAsList
3726    );
3727  }
3728
3729  public void orderByUserString2 (
3730    short order
3731  ) {
3732    refAddValue(
3733      "org:opencrx:kernel:generic:CrxObject:userString2",
3734      order
3735    );
3736  }
3737      
3738// ----------------------------------------------------------------------------
3739// Filter/ImplAttributeIsNotStruct
3740// ----------------------------------------------------------------------------
3741  public void forAllUserString3 (
3742    short operator,
3743    java.util.Collection   values
3744  ) {
3745    refAddValue(
3746      "org:opencrx:kernel:generic:CrxObject:userString3",
3747      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3748      operator,
3749      values
3750    );
3751  }
3752
3753  public void thereExistsUserString3 (
3754    short operator,
3755    java.util.Collection   values
3756  ) {
3757    refAddValue(
3758      "org:opencrx:kernel:generic:CrxObject:userString3",
3759      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3760      operator,
3761      values
3762    );
3763  }
3764
3765  public void forAllUserString3 (
3766    short operator,
3767    String  [] filterValues
3768  ) {
3769    java.util.List   arrayAsList = new java.util.ArrayList  ();
3770    for(int i = 0; i < filterValues.length; i++) {
3771      arrayAsList.add(
3772        filterValues[i]
3773      );
3774    }
3775    forAllUserString3 (
3776      operator,
3777      arrayAsList
3778    );
3779  }
3780
3781  public void thereExistsUserString3 (
3782    short operator,
3783    String  [] filterValues
3784  ) {
3785    java.util.List   arrayAsList = new java.util.ArrayList  ();
3786    for(int i = 0; i < filterValues.length; i++) {
3787      arrayAsList.add(
3788        filterValues[i]
3789      );
3790    }
3791    thereExistsUserString3 (
3792      operator,
3793      arrayAsList
3794    );
3795  }
3796
3797  public void orderByUserString3 (
3798    short order
3799  ) {
3800    refAddValue(
3801      "org:opencrx:kernel:generic:CrxObject:userString3",
3802      order
3803    );
3804  }
3805      
3806// ----------------------------------------------------------------------------
3807// Filter/ImplAttributeIsNotStruct
3808// ----------------------------------------------------------------------------
3809  public void forAllUserString4 (
3810    short operator,
3811    java.util.Collection   values
3812  ) {
3813    refAddValue(
3814      "org:opencrx:kernel:generic:CrxObject:userString4",
3815      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3816      operator,
3817      values
3818    );
3819  }
3820
3821  public void thereExistsUserString4 (
3822    short operator,
3823    java.util.Collection   values
3824  ) {
3825    refAddValue(
3826      "org:opencrx:kernel:generic:CrxObject:userString4",
3827      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3828      operator,
3829      values
3830    );
3831  }
3832
3833  public void forAllUserString4 (
3834    short operator,
3835    String  [] filterValues
3836  ) {
3837    java.util.List   arrayAsList = new java.util.ArrayList  ();
3838    for(int i = 0; i < filterValues.length; i++) {
3839      arrayAsList.add(
3840        filterValues[i]
3841      );
3842    }
3843    forAllUserString4 (
3844      operator,
3845      arrayAsList
3846    );
3847  }
3848
3849  public void thereExistsUserString4 (
3850    short operator,
3851    String  [] filterValues
3852  ) {
3853    java.util.List   arrayAsList = new java.util.ArrayList  ();
3854    for(int i = 0; i < filterValues.length; i++) {
3855      arrayAsList.add(
3856        filterValues[i]
3857      );
3858    }
3859    thereExistsUserString4 (
3860      operator,
3861      arrayAsList
3862    );
3863  }
3864
3865  public void orderByUserString4 (
3866    short order
3867  ) {
3868    refAddValue(
3869      "org:opencrx:kernel:generic:CrxObject:userString4",
3870      order
3871    );
3872  }
3873      
3874// ----------------------------------------------------------------------------
3875// Filter/ImplAttributeIsNotStruct
3876// ----------------------------------------------------------------------------
3877  public void forAllCreatedAt (
3878    short operator,
3879    java.util.Collection   values
3880  ) {
3881    refAddValue(
3882      "org:openmdx:base:BasicObject:createdAt",
3883      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3884      operator,
3885      values
3886    );
3887  }
3888
3889  public void thereExistsCreatedAt (
3890    short operator,
3891    java.util.Collection   values
3892  ) {
3893    refAddValue(
3894      "org:openmdx:base:BasicObject:createdAt",
3895      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3896      operator,
3897      values
3898    );
3899  }
3900
3901  public void forAllCreatedAt (
3902    short operator,
3903    java.util.Date  [] filterValues
3904  ) {
3905    java.util.List   arrayAsList = new java.util.ArrayList  ();
3906    for(int i = 0; i < filterValues.length; i++) {
3907      arrayAsList.add(
3908        filterValues[i]
3909      );
3910    }
3911    forAllCreatedAt (
3912      operator,
3913      arrayAsList
3914    );
3915  }
3916
3917  public void thereExistsCreatedAt (
3918    short operator,
3919    java.util.Date  [] filterValues
3920  ) {
3921    java.util.List   arrayAsList = new java.util.ArrayList  ();
3922    for(int i = 0; i < filterValues.length; i++) {
3923      arrayAsList.add(
3924        filterValues[i]
3925      );
3926    }
3927    thereExistsCreatedAt (
3928      operator,
3929      arrayAsList
3930    );
3931  }
3932
3933  public void orderByCreatedAt (
3934    short order
3935  ) {
3936    refAddValue(
3937      "org:openmdx:base:BasicObject:createdAt",
3938      order
3939    );
3940  }
3941      
3942// ----------------------------------------------------------------------------
3943// Filter/ImplAttributeIsNotStruct
3944// ----------------------------------------------------------------------------
3945  public void forAllCreatedBy (
3946    short operator,
3947    java.util.Collection   values
3948  ) {
3949    refAddValue(
3950      "org:openmdx:base:BasicObject:createdBy",
3951      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3952      operator,
3953      values
3954    );
3955  }
3956
3957  public void thereExistsCreatedBy (
3958    short operator,
3959    java.util.Collection   values
3960  ) {
3961    refAddValue(
3962      "org:openmdx:base:BasicObject:createdBy",
3963      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3964      operator,
3965      values
3966    );
3967  }
3968
3969  public void forAllCreatedBy (
3970    short operator,
3971    String  [] filterValues
3972  ) {
3973    java.util.List   arrayAsList = new java.util.ArrayList  ();
3974    for(int i = 0; i < filterValues.length; i++) {
3975      arrayAsList.add(
3976        filterValues[i]
3977      );
3978    }
3979    forAllCreatedBy (
3980      operator,
3981      arrayAsList
3982    );
3983  }
3984
3985  public void thereExistsCreatedBy (
3986    short operator,
3987    String  [] filterValues
3988  ) {
3989    java.util.List   arrayAsList = new java.util.ArrayList  ();
3990    for(int i = 0; i < filterValues.length; i++) {
3991      arrayAsList.add(
3992        filterValues[i]
3993      );
3994    }
3995    thereExistsCreatedBy (
3996      operator,
3997      arrayAsList
3998    );
3999  }
4000
4001  public void orderByCreatedBy (
4002    short order
4003  ) {
4004    refAddValue(
4005      "org:openmdx:base:BasicObject:createdBy",
4006      order
4007    );
4008  }
4009      
4010// ----------------------------------------------------------------------------
4011// Filter/ImplAttributeIsNotStruct
4012// ----------------------------------------------------------------------------
4013  public void forAllModifiedAt (
4014    short operator,
4015    java.util.Collection   values
4016  ) {
4017    refAddValue(
4018      "org:openmdx:base:BasicObject:modifiedAt",
4019      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4020      operator,
4021      values
4022    );
4023  }
4024
4025  public void thereExistsModifiedAt (
4026    short operator,
4027    java.util.Collection   values
4028  ) {
4029    refAddValue(
4030      "org:openmdx:base:BasicObject:modifiedAt",
4031      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4032      operator,
4033      values
4034    );
4035  }
4036
4037  public void forAllModifiedAt (
4038    short operator,
4039    java.util.Date  [] filterValues
4040  ) {
4041    java.util.List   arrayAsList = new java.util.ArrayList  ();
4042    for(int i = 0; i < filterValues.length; i++) {
4043      arrayAsList.add(
4044        filterValues[i]
4045      );
4046    }
4047    forAllModifiedAt (
4048      operator,
4049      arrayAsList
4050    );
4051  }
4052
4053  public void thereExistsModifiedAt (
4054    short operator,
4055    java.util.Date  [] filterValues
4056  ) {
4057    java.util.List   arrayAsList = new java.util.ArrayList  ();
4058    for(int i = 0; i < filterValues.length; i++) {
4059      arrayAsList.add(
4060        filterValues[i]
4061      );
4062    }
4063    thereExistsModifiedAt (
4064      operator,
4065      arrayAsList
4066    );
4067  }
4068
4069  public void orderByModifiedAt (
4070    short order
4071  ) {
4072    refAddValue(
4073      "org:openmdx:base:BasicObject:modifiedAt",
4074      order
4075    );
4076  }
4077      
4078// ----------------------------------------------------------------------------
4079// Filter/ImplAttributeIsNotStruct
4080// ----------------------------------------------------------------------------
4081  public void forAllModifiedBy (
4082    short operator,
4083    java.util.Collection   values
4084  ) {
4085    refAddValue(
4086      "org:openmdx:base:BasicObject:modifiedBy",
4087      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4088      operator,
4089      values
4090    );
4091  }
4092
4093  public void thereExistsModifiedBy (
4094    short operator,
4095    java.util.Collection   values
4096  ) {
4097    refAddValue(
4098      "org:openmdx:base:BasicObject:modifiedBy",
4099      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4100      operator,
4101      values
4102    );
4103  }
4104
4105  public void forAllModifiedBy (
4106    short operator,
4107    String  [] filterValues
4108  ) {
4109    java.util.List   arrayAsList = new java.util.ArrayList  ();
4110    for(int i = 0; i < filterValues.length; i++) {
4111      arrayAsList.add(
4112        filterValues[i]
4113      );
4114    }
4115    forAllModifiedBy (
4116      operator,
4117      arrayAsList
4118    );
4119  }
4120
4121  public void thereExistsModifiedBy (
4122    short operator,
4123    String  [] filterValues
4124  ) {
4125    java.util.List   arrayAsList = new java.util.ArrayList  ();
4126    for(int i = 0; i < filterValues.length; i++) {
4127      arrayAsList.add(
4128        filterValues[i]
4129      );
4130    }
4131    thereExistsModifiedBy (
4132      operator,
4133      arrayAsList
4134    );
4135  }
4136
4137  public void orderByModifiedBy (
4138    short order
4139  ) {
4140    refAddValue(
4141      "org:openmdx:base:BasicObject:modifiedBy",
4142      order
4143    );
4144  }
4145      
4146// ----------------------------------------------------------------------------
4147// Filter/ImplReference
4148// ----------------------------------------------------------------------------
4149  public void forAllContext (
4150    short operator,
4151    org.openmdx.base.cci.Context[] filterValues
4152  ) {
4153    java.util.List   arrayAsList = new java.util.ArrayList  ();
4154    for(int i = 0; i < filterValues.length; i++) {
4155      arrayAsList.add(
4156        filterValues[i]
4157      );
4158    }
4159    forAllContext (
4160      operator,
4161      arrayAsList
4162    );
4163  }
4164
4165  public void thereExistsContext (
4166    short operator,
4167    org.openmdx.base.cci.Context[] filterValues
4168  ) {
4169    java.util.List   arrayAsList = new java.util.ArrayList  ();
4170    for(int i = 0; i < filterValues.length; i++) {
4171      arrayAsList.add(
4172        filterValues[i]
4173      );
4174    }
4175    thereExistsContext (
4176      operator,
4177      arrayAsList
4178    );
4179  }
4180
4181  public void forAllContext (
4182    short operator,
4183    java.util.Collection   values
4184  ) {
4185    refAddValue(
4186      "org:openmdx:base:ContextCapable:context",
4187      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4188      operator,
4189      values
4190    );
4191  }
4192
4193  public void thereExistsContext (
4194    short operator,
4195    java.util.Collection   values
4196  ) {
4197    refAddValue(
4198      "org:openmdx:base:ContextCapable:context",
4199      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4200      operator,
4201      values
4202    );
4203  }
4204      
4205// ----------------------------------------------------------------------------
4206// Filter/ImplAttributeIsNotStruct
4207// ----------------------------------------------------------------------------
4208  public void forAllIdentity (
4209    short operator,
4210    java.util.Collection   values
4211  ) {
4212    refAddValue(
4213      "org:openmdx:base:ExtentCapable:identity",
4214      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
4215      operator,
4216      values
4217    );
4218  }
4219
4220  public void thereExistsIdentity (
4221    short operator,
4222    java.util.Collection   values
4223  ) {
4224    refAddValue(
4225      "org:openmdx:base:ExtentCapable:identity",
4226      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
4227      operator,
4228      values
4229    );
4230  }
4231
4232  public void forAllIdentity (
4233    short operator,
4234    String  [] filterValues
4235  ) {
4236    java.util.List   arrayAsList = new java.util.ArrayList  ();
4237    for(int i = 0; i < filterValues.length; i++) {
4238      arrayAsList.add(
4239        filterValues[i]
4240      );
4241    }
4242    forAllIdentity (
4243      operator,
4244      arrayAsList
4245    );
4246  }
4247
4248  public void thereExistsIdentity (
4249    short operator,
4250    String  [] filterValues
4251  ) {
4252    java.util.List   arrayAsList = new java.util.ArrayList  ();
4253    for(int i = 0; i < filterValues.length; i++) {
4254      arrayAsList.add(
4255        filterValues[i]
4256      );
4257    }
4258    thereExistsIdentity (
4259      operator,
4260      arrayAsList
4261    );
4262  }
4263
4264  public void orderByIdentity (
4265    short order
4266  ) {
4267    refAddValue(
4268      "org:openmdx:base:ExtentCapable:identity",
4269      order
4270    );
4271  }
4272      
4273// ----------------------------------------------------------------------------
4274// Filter/ImplEnd
4275// ----------------------------------------------------------------------------
4276}        
4277
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags