AbstractInvoicePositionFilterImpl


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