PostalAddressFilterImpl


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