ContractPositionFilterImpl


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 ContractPositionFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements ContractPositionFilter {
18  
19    public ContractPositionFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:contract1:ContractPosition",
25        null,
26        null
27      );
28    }
29  
30    public ContractPositionFilterImpl(
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:ContractPosition",
38        filterProperties,
39        attributeSpecifiers
40      );
41    }
42        
43  // ----------------------------------------------------------------------------
44  // Filter/ImplAttributeIsNotStruct
45  // ----------------------------------------------------------------------------
46    public void forAllAmount (
47      short operator,
48      java.util.Collection   values
49    ) {
50      refAddValue(
51        "org:opencrx:kernel:contract1:ContractPosition:amount",
52        org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53        operator,
54        values
55      );
56    }
57  
58    public void thereExistsAmount (
59      short operator,
60      java.util.Collection   values
61    ) {
62      refAddValue(
63        "org:opencrx:kernel:contract1:ContractPosition:amount",
64        org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65        operator,
66        values
67      );
68    }
69  
70    public void forAllAmount (
71      short operator,
72      java.math.BigDecimal  [] filterValues
73    ) {
74      java.util.List   arrayAsList = new java.util.ArrayList  ();
75      for(int i = 0; i < filterValues.length; i++) {
76        arrayAsList.add(
77          filterValues[i]
78        );
79      }
80      forAllAmount (
81        operator,
82        arrayAsList
83      );
84    }
85  
86    public void thereExistsAmount (
87      short operator,
88      java.math.BigDecimal  [] filterValues
89    ) {
90      java.util.List   arrayAsList = new java.util.ArrayList  ();
91      for(int i = 0; i < filterValues.length; i++) {
92        arrayAsList.add(
93          filterValues[i]
94        );
95      }
96      thereExistsAmount (
97        operator,
98        arrayAsList
99      );
100   }
101 
102   public void orderByAmount (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:contract1:ContractPosition:amount",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112 // Filter/ImplAttributeIsNotStruct
113 // ----------------------------------------------------------------------------
114   public void forAllBaseAmount (
115     short operator,
116     java.util.Collection   values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:contract1:ContractPosition:baseAmount",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125 
126   public void thereExistsBaseAmount (
127     short operator,
128     java.util.Collection   values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:contract1:ContractPosition:baseAmount",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137 
138   public void forAllBaseAmount (
139     short operator,
140     java.math.BigDecimal  [] filterValues
141   ) {
142     java.util.List   arrayAsList = new java.util.ArrayList  ();
143     for(int i = 0; i < filterValues.length; i++) {
144       arrayAsList.add(
145         filterValues[i]
146       );
147     }
148     forAllBaseAmount (
149       operator,
150       arrayAsList
151     );
152   }
153 
154   public void thereExistsBaseAmount (
155     short operator,
156     java.math.BigDecimal  [] filterValues
157   ) {
158     java.util.List   arrayAsList = new java.util.ArrayList  ();
159     for(int i = 0; i < filterValues.length; i++) {
160       arrayAsList.add(
161         filterValues[i]
162       );
163     }
164     thereExistsBaseAmount (
165       operator,
166       arrayAsList
167     );
168   }
169 
170   public void orderByBaseAmount (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:contract1:ContractPosition:baseAmount",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180 // Filter/ImplReference
181 // ----------------------------------------------------------------------------
182   public void forAllContact (
183     short operator,
184     org.opencrx.kernel.account1.cci.Contact[] filterValues
185   ) {
186     java.util.List   arrayAsList = new java.util.ArrayList  ();
187     for(int i = 0; i < filterValues.length; i++) {
188       arrayAsList.add(
189         filterValues[i]
190       );
191     }
192     forAllContact (
193       operator,
194       arrayAsList
195     );
196   }
197 
198   public void thereExistsContact (
199     short operator,
200     org.opencrx.kernel.account1.cci.Contact[] filterValues
201   ) {
202     java.util.List   arrayAsList = new java.util.ArrayList  ();
203     for(int i = 0; i < filterValues.length; i++) {
204       arrayAsList.add(
205         filterValues[i]
206       );
207     }
208     thereExistsContact (
209       operator,
210       arrayAsList
211     );
212   }
213 
214   public void forAllContact (
215     short operator,
216     java.util.Collection   values
217   ) {
218     refAddValue(
219       "org:opencrx:kernel:contract1:ContractPosition:contact",
220       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
221       operator,
222       values
223     );
224   }
225 
226   public void thereExistsContact (
227     short operator,
228     java.util.Collection   values
229   ) {
230     refAddValue(
231       "org:opencrx:kernel:contract1:ContractPosition:contact",
232       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
233       operator,
234       values
235     );
236   }
237       
238 // ----------------------------------------------------------------------------
239 // Filter/ImplAttributeIsNotStruct
240 // ----------------------------------------------------------------------------
241   public void forAllContractPositionState (
242     short operator,
243     java.util.Collection   values
244   ) {
245     refAddValue(
246       "org:opencrx:kernel:contract1:ContractPosition:contractPositionState",
247       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
248       operator,
249       values
250     );
251   }
252 
253   public void thereExistsContractPositionState (
254     short operator,
255     java.util.Collection   values
256   ) {
257     refAddValue(
258       "org:opencrx:kernel:contract1:ContractPosition:contractPositionState",
259       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
260       operator,
261       values
262     );
263   }
264 
265   public void forAllContractPositionState (
266     short operator,
267     short[] filterValues
268   ) {
269     java.util.List   arrayAsList = new java.util.ArrayList  ();
270     for(int i = 0; i < filterValues.length; i++) {
271       arrayAsList.add(
272         new Short  (filterValues[i])
273       );
274     }
275     forAllContractPositionState (
276       operator,
277       arrayAsList
278     );
279   }
280 
281   public void thereExistsContractPositionState (
282     short operator,
283     short[] filterValues
284   ) {
285     java.util.List   arrayAsList = new java.util.ArrayList  ();
286     for(int i = 0; i < filterValues.length; i++) {
287       arrayAsList.add(
288         new Short  (filterValues[i])
289       );
290     }
291     thereExistsContractPositionState (
292       operator,
293       arrayAsList
294     );
295   }
296 
297   public void orderByContractPositionState (
298     short order
299   ) {
300     refAddValue(
301       "org:opencrx:kernel:contract1:ContractPosition:contractPositionState",
302       order
303     );
304   }
305       
306 // ----------------------------------------------------------------------------
307 // Filter/ImplAttributeIsNotStruct
308 // ----------------------------------------------------------------------------
309   public void forAllDescription (
310     short operator,
311     java.util.Collection   values
312   ) {
313     refAddValue(
314       "org:opencrx:kernel:contract1:ContractPosition:description",
315       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
316       operator,
317       values
318     );
319   }
320 
321   public void thereExistsDescription (
322     short operator,
323     java.util.Collection   values
324   ) {
325     refAddValue(
326       "org:opencrx:kernel:contract1:ContractPosition:description",
327       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
328       operator,
329       values
330     );
331   }
332 
333   public void forAllDescription (
334     short operator,
335     String  [] filterValues
336   ) {
337     java.util.List   arrayAsList = new java.util.ArrayList  ();
338     for(int i = 0; i < filterValues.length; i++) {
339       arrayAsList.add(
340         filterValues[i]
341       );
342     }
343     forAllDescription (
344       operator,
345       arrayAsList
346     );
347   }
348 
349   public void thereExistsDescription (
350     short operator,
351     String  [] filterValues
352   ) {
353     java.util.List   arrayAsList = new java.util.ArrayList  ();
354     for(int i = 0; i < filterValues.length; i++) {
355       arrayAsList.add(
356         filterValues[i]
357       );
358     }
359     thereExistsDescription (
360       operator,
361       arrayAsList
362     );
363   }
364 
365   public void orderByDescription (
366     short order
367   ) {
368     refAddValue(
369       "org:opencrx:kernel:contract1:ContractPosition:description",
370       order
371     );
372   }
373       
374 // ----------------------------------------------------------------------------
375 // Filter/ImplAttributeIsNotStruct
376 // ----------------------------------------------------------------------------
377   public void forAllDiscount (
378     short operator,
379     java.util.Collection   values
380   ) {
381     refAddValue(
382       "org:opencrx:kernel:contract1:ContractPosition:discount",
383       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
384       operator,
385       values
386     );
387   }
388 
389   public void thereExistsDiscount (
390     short operator,
391     java.util.Collection   values
392   ) {
393     refAddValue(
394       "org:opencrx:kernel:contract1:ContractPosition:discount",
395       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
396       operator,
397       values
398     );
399   }
400 
401   public void forAllDiscount (
402     short operator,
403     java.math.BigDecimal  [] filterValues
404   ) {
405     java.util.List   arrayAsList = new java.util.ArrayList  ();
406     for(int i = 0; i < filterValues.length; i++) {
407       arrayAsList.add(
408         filterValues[i]
409       );
410     }
411     forAllDiscount (
412       operator,
413       arrayAsList
414     );
415   }
416 
417   public void thereExistsDiscount (
418     short operator,
419     java.math.BigDecimal  [] filterValues
420   ) {
421     java.util.List   arrayAsList = new java.util.ArrayList  ();
422     for(int i = 0; i < filterValues.length; i++) {
423       arrayAsList.add(
424         filterValues[i]
425       );
426     }
427     thereExistsDiscount (
428       operator,
429       arrayAsList
430     );
431   }
432 
433   public void orderByDiscount (
434     short order
435   ) {
436     refAddValue(
437       "org:opencrx:kernel:contract1:ContractPosition:discount",
438       order
439     );
440   }
441       
442 // ----------------------------------------------------------------------------
443 // Filter/ImplAttributeIsNotStruct
444 // ----------------------------------------------------------------------------
445   public void forAllDiscountAmount (
446     short operator,
447     java.util.Collection   values
448   ) {
449     refAddValue(
450       "org:opencrx:kernel:contract1:ContractPosition:discountAmount",
451       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
452       operator,
453       values
454     );
455   }
456 
457   public void thereExistsDiscountAmount (
458     short operator,
459     java.util.Collection   values
460   ) {
461     refAddValue(
462       "org:opencrx:kernel:contract1:ContractPosition:discountAmount",
463       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
464       operator,
465       values
466     );
467   }
468 
469   public void forAllDiscountAmount (
470     short operator,
471     java.math.BigDecimal  [] filterValues
472   ) {
473     java.util.List   arrayAsList = new java.util.ArrayList  ();
474     for(int i = 0; i < filterValues.length; i++) {
475       arrayAsList.add(
476         filterValues[i]
477       );
478     }
479     forAllDiscountAmount (
480       operator,
481       arrayAsList
482     );
483   }
484 
485   public void thereExistsDiscountAmount (
486     short operator,
487     java.math.BigDecimal  [] filterValues
488   ) {
489     java.util.List   arrayAsList = new java.util.ArrayList  ();
490     for(int i = 0; i < filterValues.length; i++) {
491       arrayAsList.add(
492         filterValues[i]
493       );
494     }
495     thereExistsDiscountAmount (
496       operator,
497       arrayAsList
498     );
499   }
500 
501   public void orderByDiscountAmount (
502     short order
503   ) {
504     refAddValue(
505       "org:opencrx:kernel:contract1:ContractPosition:discountAmount",
506       order
507     );
508   }
509       
510 // ----------------------------------------------------------------------------
511 // Filter/ImplAttributeIsNotStruct
512 // ----------------------------------------------------------------------------
513   public void forAllDiscountDescription (
514     short operator,
515     java.util.Collection   values
516   ) {
517     refAddValue(
518       "org:opencrx:kernel:contract1:ContractPosition:discountDescription",
519       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
520       operator,
521       values
522     );
523   }
524 
525   public void thereExistsDiscountDescription (
526     short operator,
527     java.util.Collection   values
528   ) {
529     refAddValue(
530       "org:opencrx:kernel:contract1:ContractPosition:discountDescription",
531       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
532       operator,
533       values
534     );
535   }
536 
537   public void forAllDiscountDescription (
538     short operator,
539     String  [] filterValues
540   ) {
541     java.util.List   arrayAsList = new java.util.ArrayList  ();
542     for(int i = 0; i < filterValues.length; i++) {
543       arrayAsList.add(
544         filterValues[i]
545       );
546     }
547     forAllDiscountDescription (
548       operator,
549       arrayAsList
550     );
551   }
552 
553   public void thereExistsDiscountDescription (
554     short operator,
555     String  [] filterValues
556   ) {
557     java.util.List   arrayAsList = new java.util.ArrayList  ();
558     for(int i = 0; i < filterValues.length; i++) {
559       arrayAsList.add(
560         filterValues[i]
561       );
562     }
563     thereExistsDiscountDescription (
564       operator,
565       arrayAsList
566     );
567   }
568 
569   public void orderByDiscountDescription (
570     short order
571   ) {
572     refAddValue(
573       "org:opencrx:kernel:contract1:ContractPosition:discountDescription",
574       order
575     );
576   }
577       
578 // ----------------------------------------------------------------------------
579 // Filter/ImplAttributeIsNotStruct
580 // ----------------------------------------------------------------------------
581   public void forAllDiscountIsPercentage (
582     short operator,
583     java.util.Collection   values
584   ) {
585     refAddValue(
586       "org:opencrx:kernel:contract1:ContractPosition:discountIsPercentage",
587       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
588       operator,
589       values
590     );
591   }
592 
593   public void thereExistsDiscountIsPercentage (
594     short operator,
595     java.util.Collection   values
596   ) {
597     refAddValue(
598       "org:opencrx:kernel:contract1:ContractPosition:discountIsPercentage",
599       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
600       operator,
601       values
602     );
603   }
604 
605   public void forAllDiscountIsPercentage (
606     short operator,
607     boolean[] filterValues
608   ) {
609     java.util.List   arrayAsList = new java.util.ArrayList  ();
610     for(int i = 0; i < filterValues.length; i++) {
611       arrayAsList.add(
612         new Boolean  (filterValues[i])
613       );
614     }
615     forAllDiscountIsPercentage (
616       operator,
617       arrayAsList
618     );
619   }
620 
621   public void thereExistsDiscountIsPercentage (
622     short operator,
623     boolean[] filterValues
624   ) {
625     java.util.List   arrayAsList = new java.util.ArrayList  ();
626     for(int i = 0; i < filterValues.length; i++) {
627       arrayAsList.add(
628         new Boolean  (filterValues[i])
629       );
630     }
631     thereExistsDiscountIsPercentage (
632       operator,
633       arrayAsList
634     );
635   }
636 
637   public void orderByDiscountIsPercentage (
638     short order
639   ) {
640     refAddValue(
641       "org:opencrx:kernel:contract1:ContractPosition:discountIsPercentage",
642       order
643     );
644   }
645       
646 // ----------------------------------------------------------------------------
647 // Filter/ImplAttributeIsNotStruct
648 // ----------------------------------------------------------------------------
649   public void forAllLineItemNumber (
650     short operator,
651     java.util.Collection   values
652   ) {
653     refAddValue(
654       "org:opencrx:kernel:contract1:ContractPosition:lineItemNumber",
655       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
656       operator,
657       values
658     );
659   }
660 
661   public void thereExistsLineItemNumber (
662     short operator,
663     java.util.Collection   values
664   ) {
665     refAddValue(
666       "org:opencrx:kernel:contract1:ContractPosition:lineItemNumber",
667       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
668       operator,
669       values
670     );
671   }
672 
673   public void forAllLineItemNumber (
674     short operator,
675     int[] filterValues
676   ) {
677     java.util.List   arrayAsList = new java.util.ArrayList  ();
678     for(int i = 0; i < filterValues.length; i++) {
679       arrayAsList.add(
680         new Integer  (filterValues[i])
681       );
682     }
683     forAllLineItemNumber (
684       operator,
685       arrayAsList
686     );
687   }
688 
689   public void thereExistsLineItemNumber (
690     short operator,
691     int[] filterValues
692   ) {
693     java.util.List   arrayAsList = new java.util.ArrayList  ();
694     for(int i = 0; i < filterValues.length; i++) {
695       arrayAsList.add(
696         new Integer  (filterValues[i])
697       );
698     }
699     thereExistsLineItemNumber (
700       operator,
701       arrayAsList
702     );
703   }
704 
705   public void orderByLineItemNumber (
706     short order
707   ) {
708     refAddValue(
709       "org:opencrx:kernel:contract1:ContractPosition:lineItemNumber",
710       order
711     );
712   }
713       
714 // ----------------------------------------------------------------------------
715 // Filter/ImplReference
716 // ----------------------------------------------------------------------------
717   public void forAllListPrice (
718     short operator,
719     org.opencrx.kernel.product1.cci.ProductBasePrice[] filterValues
720   ) {
721     java.util.List   arrayAsList = new java.util.ArrayList  ();
722     for(int i = 0; i < filterValues.length; i++) {
723       arrayAsList.add(
724         filterValues[i]
725       );
726     }
727     forAllListPrice (
728       operator,
729       arrayAsList
730     );
731   }
732 
733   public void thereExistsListPrice (
734     short operator,
735     org.opencrx.kernel.product1.cci.ProductBasePrice[] filterValues
736   ) {
737     java.util.List   arrayAsList = new java.util.ArrayList  ();
738     for(int i = 0; i < filterValues.length; i++) {
739       arrayAsList.add(
740         filterValues[i]
741       );
742     }
743     thereExistsListPrice (
744       operator,
745       arrayAsList
746     );
747   }
748 
749   public void forAllListPrice (
750     short operator,
751     java.util.Collection   values
752   ) {
753     refAddValue(
754       "org:opencrx:kernel:contract1:ContractPosition:listPrice",
755       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
756       operator,
757       values
758     );
759   }
760 
761   public void thereExistsListPrice (
762     short operator,
763     java.util.Collection   values
764   ) {
765     refAddValue(
766       "org:opencrx:kernel:contract1:ContractPosition:listPrice",
767       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
768       operator,
769       values
770     );
771   }
772       
773 // ----------------------------------------------------------------------------
774 // Filter/ImplAttributeIsNotStruct
775 // ----------------------------------------------------------------------------
776   public void forAllMaxQuantity (
777     short operator,
778     java.util.Collection   values
779   ) {
780     refAddValue(
781       "org:opencrx:kernel:contract1:ContractPosition:maxQuantity",
782       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
783       operator,
784       values
785     );
786   }
787 
788   public void thereExistsMaxQuantity (
789     short operator,
790     java.util.Collection   values
791   ) {
792     refAddValue(
793       "org:opencrx:kernel:contract1:ContractPosition:maxQuantity",
794       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
795       operator,
796       values
797     );
798   }
799 
800   public void forAllMaxQuantity (
801     short operator,
802     java.math.BigDecimal  [] filterValues
803   ) {
804     java.util.List   arrayAsList = new java.util.ArrayList  ();
805     for(int i = 0; i < filterValues.length; i++) {
806       arrayAsList.add(
807         filterValues[i]
808       );
809     }
810     forAllMaxQuantity (
811       operator,
812       arrayAsList
813     );
814   }
815 
816   public void thereExistsMaxQuantity (
817     short operator,
818     java.math.BigDecimal  [] filterValues
819   ) {
820     java.util.List   arrayAsList = new java.util.ArrayList  ();
821     for(int i = 0; i < filterValues.length; i++) {
822       arrayAsList.add(
823         filterValues[i]
824       );
825     }
826     thereExistsMaxQuantity (
827       operator,
828       arrayAsList
829     );
830   }
831 
832   public void orderByMaxQuantity (
833     short order
834   ) {
835     refAddValue(
836       "org:opencrx:kernel:contract1:ContractPosition:maxQuantity",
837       order
838     );
839   }
840       
841 // ----------------------------------------------------------------------------
842 // Filter/ImplAttributeIsNotStruct
843 // ----------------------------------------------------------------------------
844   public void forAllMinMaxQuantityHandling (
845     short operator,
846     java.util.Collection   values
847   ) {
848     refAddValue(
849       "org:opencrx:kernel:contract1:ContractPosition:minMaxQuantityHandling",
850       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
851       operator,
852       values
853     );
854   }
855 
856   public void thereExistsMinMaxQuantityHandling (
857     short operator,
858     java.util.Collection   values
859   ) {
860     refAddValue(
861       "org:opencrx:kernel:contract1:ContractPosition:minMaxQuantityHandling",
862       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
863       operator,
864       values
865     );
866   }
867 
868   public void forAllMinMaxQuantityHandling (
869     short operator,
870     short[] filterValues
871   ) {
872     java.util.List   arrayAsList = new java.util.ArrayList  ();
873     for(int i = 0; i < filterValues.length; i++) {
874       arrayAsList.add(
875         new Short  (filterValues[i])
876       );
877     }
878     forAllMinMaxQuantityHandling (
879       operator,
880       arrayAsList
881     );
882   }
883 
884   public void thereExistsMinMaxQuantityHandling (
885     short operator,
886     short[] filterValues
887   ) {
888     java.util.List   arrayAsList = new java.util.ArrayList  ();
889     for(int i = 0; i < filterValues.length; i++) {
890       arrayAsList.add(
891         new Short  (filterValues[i])
892       );
893     }
894     thereExistsMinMaxQuantityHandling (
895       operator,
896       arrayAsList
897     );
898   }
899 
900   public void orderByMinMaxQuantityHandling (
901     short order
902   ) {
903     refAddValue(
904       "org:opencrx:kernel:contract1:ContractPosition:minMaxQuantityHandling",
905       order
906     );
907   }
908       
909 // ----------------------------------------------------------------------------
910 // Filter/ImplAttributeIsNotStruct
911 // ----------------------------------------------------------------------------
912   public void forAllMinQuantity (
913     short operator,
914     java.util.Collection   values
915   ) {
916     refAddValue(
917       "org:opencrx:kernel:contract1:ContractPosition:minQuantity",
918       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
919       operator,
920       values
921     );
922   }
923 
924   public void thereExistsMinQuantity (
925     short operator,
926     java.util.Collection   values
927   ) {
928     refAddValue(
929       "org:opencrx:kernel:contract1:ContractPosition:minQuantity",
930       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
931       operator,
932       values
933     );
934   }
935 
936   public void forAllMinQuantity (
937     short operator,
938     java.math.BigDecimal  [] filterValues
939   ) {
940     java.util.List   arrayAsList = new java.util.ArrayList  ();
941     for(int i = 0; i < filterValues.length; i++) {
942       arrayAsList.add(
943         filterValues[i]
944       );
945     }
946     forAllMinQuantity (
947       operator,
948       arrayAsList
949     );
950   }
951 
952   public void thereExistsMinQuantity (
953     short operator,
954     java.math.BigDecimal  [] filterValues
955   ) {
956     java.util.List   arrayAsList = new java.util.ArrayList  ();
957     for(int i = 0; i < filterValues.length; i++) {
958       arrayAsList.add(
959         filterValues[i]
960       );
961     }
962     thereExistsMinQuantity (
963       operator,
964       arrayAsList
965     );
966   }
967 
968   public void orderByMinQuantity (
969     short order
970   ) {
971     refAddValue(
972       "org:opencrx:kernel:contract1:ContractPosition:minQuantity",
973       order
974     );
975   }
976       
977 // ----------------------------------------------------------------------------
978 // Filter/ImplAttributeIsNotStruct
979 // ----------------------------------------------------------------------------
980   public void forAllName (
981     short operator,
982     java.util.Collection   values
983   ) {
984     refAddValue(
985       "org:opencrx:kernel:contract1:ContractPosition:name",
986       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
987       operator,
988       values
989     );
990   }
991 
992   public void thereExistsName (
993     short operator,
994     java.util.Collection   values
995   ) {
996     refAddValue(
997       "org:opencrx:kernel:contract1:ContractPosition:name",
998       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
999       operator,
1000      values
1001    );
1002  }
1003
1004  public void forAllName (
1005    short operator,
1006    String  [] filterValues
1007  ) {
1008    java.util.List   arrayAsList = new java.util.ArrayList  ();
1009    for(int i = 0; i < filterValues.length; i++) {
1010      arrayAsList.add(
1011        filterValues[i]
1012      );
1013    }
1014    forAllName (
1015      operator,
1016      arrayAsList
1017    );
1018  }
1019
1020  public void thereExistsName (
1021    short operator,
1022    String  [] filterValues
1023  ) {
1024    java.util.List   arrayAsList = new java.util.ArrayList  ();
1025    for(int i = 0; i < filterValues.length; i++) {
1026      arrayAsList.add(
1027        filterValues[i]
1028      );
1029    }
1030    thereExistsName (
1031      operator,
1032      arrayAsList
1033    );
1034  }
1035
1036  public void orderByName (
1037    short order
1038  ) {
1039    refAddValue(
1040      "org:opencrx:kernel:contract1:ContractPosition:name",
1041      order
1042    );
1043  }
1044      
1045// ----------------------------------------------------------------------------
1046// Filter/ImplAttributeIsNotStruct
1047// ----------------------------------------------------------------------------
1048  public void forAllOffsetQuantity (
1049    short operator,
1050    java.util.Collection   values
1051  ) {
1052    refAddValue(
1053      "org:opencrx:kernel:contract1:ContractPosition:offsetQuantity",
1054      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1055      operator,
1056      values
1057    );
1058  }
1059
1060  public void thereExistsOffsetQuantity (
1061    short operator,
1062    java.util.Collection   values
1063  ) {
1064    refAddValue(
1065      "org:opencrx:kernel:contract1:ContractPosition:offsetQuantity",
1066      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1067      operator,
1068      values
1069    );
1070  }
1071
1072  public void forAllOffsetQuantity (
1073    short operator,
1074    java.math.BigDecimal  [] filterValues
1075  ) {
1076    java.util.List   arrayAsList = new java.util.ArrayList  ();
1077    for(int i = 0; i < filterValues.length; i++) {
1078      arrayAsList.add(
1079        filterValues[i]
1080      );
1081    }
1082    forAllOffsetQuantity (
1083      operator,
1084      arrayAsList
1085    );
1086  }
1087
1088  public void thereExistsOffsetQuantity (
1089    short operator,
1090    java.math.BigDecimal  [] filterValues
1091  ) {
1092    java.util.List   arrayAsList = new java.util.ArrayList  ();
1093    for(int i = 0; i < filterValues.length; i++) {
1094      arrayAsList.add(
1095        filterValues[i]
1096      );
1097    }
1098    thereExistsOffsetQuantity (
1099      operator,
1100      arrayAsList
1101    );
1102  }
1103
1104  public void orderByOffsetQuantity (
1105    short order
1106  ) {
1107    refAddValue(
1108      "org:opencrx:kernel:contract1:ContractPosition:offsetQuantity",
1109      order
1110    );
1111  }
1112      
1113// ----------------------------------------------------------------------------
1114// Filter/ImplAttributeIsNotStruct
1115// ----------------------------------------------------------------------------
1116  public void forAllPositionNumber (
1117    short operator,
1118    java.util.Collection   values
1119  ) {
1120    refAddValue(
1121      "org:opencrx:kernel:contract1:ContractPosition:positionNumber",
1122      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1123      operator,
1124      values
1125    );
1126  }
1127
1128  public void thereExistsPositionNumber (
1129    short operator,
1130    java.util.Collection   values
1131  ) {
1132    refAddValue(
1133      "org:opencrx:kernel:contract1:ContractPosition:positionNumber",
1134      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1135      operator,
1136      values
1137    );
1138  }
1139
1140  public void forAllPositionNumber (
1141    short operator,
1142    String  [] filterValues
1143  ) {
1144    java.util.List   arrayAsList = new java.util.ArrayList  ();
1145    for(int i = 0; i < filterValues.length; i++) {
1146      arrayAsList.add(
1147        filterValues[i]
1148      );
1149    }
1150    forAllPositionNumber (
1151      operator,
1152      arrayAsList
1153    );
1154  }
1155
1156  public void thereExistsPositionNumber (
1157    short operator,
1158    String  [] filterValues
1159  ) {
1160    java.util.List   arrayAsList = new java.util.ArrayList  ();
1161    for(int i = 0; i < filterValues.length; i++) {
1162      arrayAsList.add(
1163        filterValues[i]
1164      );
1165    }
1166    thereExistsPositionNumber (
1167      operator,
1168      arrayAsList
1169    );
1170  }
1171
1172  public void orderByPositionNumber (
1173    short order
1174  ) {
1175    refAddValue(
1176      "org:opencrx:kernel:contract1:ContractPosition:positionNumber",
1177      order
1178    );
1179  }
1180      
1181// ----------------------------------------------------------------------------
1182// Filter/ImplReference
1183// ----------------------------------------------------------------------------
1184  public void forAllPriceLevel (
1185    short operator,
1186    org.opencrx.kernel.product1.cci.PriceLevel[] filterValues
1187  ) {
1188    java.util.List   arrayAsList = new java.util.ArrayList  ();
1189    for(int i = 0; i < filterValues.length; i++) {
1190      arrayAsList.add(
1191        filterValues[i]
1192      );
1193    }
1194    forAllPriceLevel (
1195      operator,
1196      arrayAsList
1197    );
1198  }
1199
1200  public void thereExistsPriceLevel (
1201    short operator,
1202    org.opencrx.kernel.product1.cci.PriceLevel[] filterValues
1203  ) {
1204    java.util.List   arrayAsList = new java.util.ArrayList  ();
1205    for(int i = 0; i < filterValues.length; i++) {
1206      arrayAsList.add(
1207        filterValues[i]
1208      );
1209    }
1210    thereExistsPriceLevel (
1211      operator,
1212      arrayAsList
1213    );
1214  }
1215
1216  public void forAllPriceLevel (
1217    short operator,
1218    java.util.Collection   values
1219  ) {
1220    refAddValue(
1221      "org:opencrx:kernel:contract1:ContractPosition:priceLevel",
1222      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1223      operator,
1224      values
1225    );
1226  }
1227
1228  public void thereExistsPriceLevel (
1229    short operator,
1230    java.util.Collection   values
1231  ) {
1232    refAddValue(
1233      "org:opencrx:kernel:contract1:ContractPosition:priceLevel",
1234      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1235      operator,
1236      values
1237    );
1238  }
1239      
1240// ----------------------------------------------------------------------------
1241// Filter/ImplAttributeIsNotStruct
1242// ----------------------------------------------------------------------------
1243  public void forAllPricePerUnit (
1244    short operator,
1245    java.util.Collection   values
1246  ) {
1247    refAddValue(
1248      "org:opencrx:kernel:contract1:ContractPosition:pricePerUnit",
1249      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1250      operator,
1251      values
1252    );
1253  }
1254
1255  public void thereExistsPricePerUnit (
1256    short operator,
1257    java.util.Collection   values
1258  ) {
1259    refAddValue(
1260      "org:opencrx:kernel:contract1:ContractPosition:pricePerUnit",
1261      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1262      operator,
1263      values
1264    );
1265  }
1266
1267  public void forAllPricePerUnit (
1268    short operator,
1269    java.math.BigDecimal  [] filterValues
1270  ) {
1271    java.util.List   arrayAsList = new java.util.ArrayList  ();
1272    for(int i = 0; i < filterValues.length; i++) {
1273      arrayAsList.add(
1274        filterValues[i]
1275      );
1276    }
1277    forAllPricePerUnit (
1278      operator,
1279      arrayAsList
1280    );
1281  }
1282
1283  public void thereExistsPricePerUnit (
1284    short operator,
1285    java.math.BigDecimal  [] filterValues
1286  ) {
1287    java.util.List   arrayAsList = new java.util.ArrayList  ();
1288    for(int i = 0; i < filterValues.length; i++) {
1289      arrayAsList.add(
1290        filterValues[i]
1291      );
1292    }
1293    thereExistsPricePerUnit (
1294      operator,
1295      arrayAsList
1296    );
1297  }
1298
1299  public void orderByPricePerUnit (
1300    short order
1301  ) {
1302    refAddValue(
1303      "org:opencrx:kernel:contract1:ContractPosition:pricePerUnit",
1304      order
1305    );
1306  }
1307      
1308// ----------------------------------------------------------------------------
1309// Filter/ImplReference
1310// ----------------------------------------------------------------------------
1311  public void forAllPriceUom (
1312    short operator,
1313    org.opencrx.kernel.uom1.cci.Uom[] filterValues
1314  ) {
1315    java.util.List   arrayAsList = new java.util.ArrayList  ();
1316    for(int i = 0; i < filterValues.length; i++) {
1317      arrayAsList.add(
1318        filterValues[i]
1319      );
1320    }
1321    forAllPriceUom (
1322      operator,
1323      arrayAsList
1324    );
1325  }
1326
1327  public void thereExistsPriceUom (
1328    short operator,
1329    org.opencrx.kernel.uom1.cci.Uom[] filterValues
1330  ) {
1331    java.util.List   arrayAsList = new java.util.ArrayList  ();
1332    for(int i = 0; i < filterValues.length; i++) {
1333      arrayAsList.add(
1334        filterValues[i]
1335      );
1336    }
1337    thereExistsPriceUom (
1338      operator,
1339      arrayAsList
1340    );
1341  }
1342
1343  public void forAllPriceUom (
1344    short operator,
1345    java.util.Collection   values
1346  ) {
1347    refAddValue(
1348      "org:opencrx:kernel:contract1:ContractPosition:priceUom",
1349      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1350      operator,
1351      values
1352    );
1353  }
1354
1355  public void thereExistsPriceUom (
1356    short operator,
1357    java.util.Collection   values
1358  ) {
1359    refAddValue(
1360      "org:opencrx:kernel:contract1:ContractPosition:priceUom",
1361      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1362      operator,
1363      values
1364    );
1365  }
1366      
1367// ----------------------------------------------------------------------------
1368// Filter/ImplAttributeIsNotStruct
1369// ----------------------------------------------------------------------------
1370  public void forAllPriceUomDescription (
1371    short operator,
1372    java.util.Collection   values
1373  ) {
1374    refAddValue(
1375      "org:opencrx:kernel:contract1:ContractPosition:priceUomDescription",
1376      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1377      operator,
1378      values
1379    );
1380  }
1381
1382  public void thereExistsPriceUomDescription (
1383    short operator,
1384    java.util.Collection   values
1385  ) {
1386    refAddValue(
1387      "org:opencrx:kernel:contract1:ContractPosition:priceUomDescription",
1388      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1389      operator,
1390      values
1391    );
1392  }
1393
1394  public void forAllPriceUomDescription (
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    forAllPriceUomDescription (
1405      operator,
1406      arrayAsList
1407    );
1408  }
1409
1410  public void thereExistsPriceUomDescription (
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    thereExistsPriceUomDescription (
1421      operator,
1422      arrayAsList
1423    );
1424  }
1425
1426  public void orderByPriceUomDescription (
1427    short order
1428  ) {
1429    refAddValue(
1430      "org:opencrx:kernel:contract1:ContractPosition:priceUomDescription",
1431      order
1432    );
1433  }
1434      
1435// ----------------------------------------------------------------------------
1436// Filter/ImplAttributeIsNotStruct
1437// ----------------------------------------------------------------------------
1438  public void forAllPriceUomDetailedDescription (
1439    short operator,
1440    java.util.Collection   values
1441  ) {
1442    refAddValue(
1443      "org:opencrx:kernel:contract1:ContractPosition:priceUomDetailedDescription",
1444      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1445      operator,
1446      values
1447    );
1448  }
1449
1450  public void thereExistsPriceUomDetailedDescription (
1451    short operator,
1452    java.util.Collection   values
1453  ) {
1454    refAddValue(
1455      "org:opencrx:kernel:contract1:ContractPosition:priceUomDetailedDescription",
1456      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1457      operator,
1458      values
1459    );
1460  }
1461
1462  public void forAllPriceUomDetailedDescription (
1463    short operator,
1464    String  [] 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    forAllPriceUomDetailedDescription (
1473      operator,
1474      arrayAsList
1475    );
1476  }
1477
1478  public void thereExistsPriceUomDetailedDescription (
1479    short operator,
1480    String  [] 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    thereExistsPriceUomDetailedDescription (
1489      operator,
1490      arrayAsList
1491    );
1492  }
1493
1494  public void orderByPriceUomDetailedDescription (
1495    short order
1496  ) {
1497    refAddValue(
1498      "org:opencrx:kernel:contract1:ContractPosition:priceUomDetailedDescription",
1499      order
1500    );
1501  }
1502      
1503// ----------------------------------------------------------------------------
1504// Filter/ImplAttributeIsNotStruct
1505// ----------------------------------------------------------------------------
1506  public void forAllPricingDate (
1507    short operator,
1508    java.util.Collection   values
1509  ) {
1510    refAddValue(
1511      "org:opencrx:kernel:contract1:ContractPosition:pricingDate",
1512      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1513      operator,
1514      values
1515    );
1516  }
1517
1518  public void thereExistsPricingDate (
1519    short operator,
1520    java.util.Collection   values
1521  ) {
1522    refAddValue(
1523      "org:opencrx:kernel:contract1:ContractPosition:pricingDate",
1524      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1525      operator,
1526      values
1527    );
1528  }
1529
1530  public void forAllPricingDate (
1531    short operator,
1532    java.util.Date  [] 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    forAllPricingDate (
1541      operator,
1542      arrayAsList
1543    );
1544  }
1545
1546  public void thereExistsPricingDate (
1547    short operator,
1548    java.util.Date  [] 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    thereExistsPricingDate (
1557      operator,
1558      arrayAsList
1559    );
1560  }
1561
1562  public void orderByPricingDate (
1563    short order
1564  ) {
1565    refAddValue(
1566      "org:opencrx:kernel:contract1:ContractPosition:pricingDate",
1567      order
1568    );
1569  }
1570      
1571// ----------------------------------------------------------------------------
1572// Filter/ImplReference
1573// ----------------------------------------------------------------------------
1574  public void forAllPricingRule (
1575    short operator,
1576    org.opencrx.kernel.product1.cci.PricingRule[] 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    forAllPricingRule (
1585      operator,
1586      arrayAsList
1587    );
1588  }
1589
1590  public void thereExistsPricingRule (
1591    short operator,
1592    org.opencrx.kernel.product1.cci.PricingRule[] 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    thereExistsPricingRule (
1601      operator,
1602      arrayAsList
1603    );
1604  }
1605
1606  public void forAllPricingRule (
1607    short operator,
1608    java.util.Collection   values
1609  ) {
1610    refAddValue(
1611      "org:opencrx:kernel:contract1:ContractPosition:pricingRule",
1612      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1613      operator,
1614      values
1615    );
1616  }
1617
1618  public void thereExistsPricingRule (
1619    short operator,
1620    java.util.Collection   values
1621  ) {
1622    refAddValue(
1623      "org:opencrx:kernel:contract1:ContractPosition:pricingRule",
1624      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1625      operator,
1626      values
1627    );
1628  }
1629      
1630// ----------------------------------------------------------------------------
1631// Filter/ImplAttributeIsNotStruct
1632// ----------------------------------------------------------------------------
1633  public void forAllPricingState (
1634    short operator,
1635    java.util.Collection   values
1636  ) {
1637    refAddValue(
1638      "org:opencrx:kernel:contract1:ContractPosition:pricingState",
1639      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1640      operator,
1641      values
1642    );
1643  }
1644
1645  public void thereExistsPricingState (
1646    short operator,
1647    java.util.Collection   values
1648  ) {
1649    refAddValue(
1650      "org:opencrx:kernel:contract1:ContractPosition:pricingState",
1651      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1652      operator,
1653      values
1654    );
1655  }
1656
1657  public void forAllPricingState (
1658    short operator,
1659    short[] filterValues
1660  ) {
1661    java.util.List   arrayAsList = new java.util.ArrayList  ();
1662    for(int i = 0; i < filterValues.length; i++) {
1663      arrayAsList.add(
1664        new Short  (filterValues[i])
1665      );
1666    }
1667    forAllPricingState (
1668      operator,
1669      arrayAsList
1670    );
1671  }
1672
1673  public void thereExistsPricingState (
1674    short operator,
1675    short[] filterValues
1676  ) {
1677    java.util.List   arrayAsList = new java.util.ArrayList  ();
1678    for(int i = 0; i < filterValues.length; i++) {
1679      arrayAsList.add(
1680        new Short  (filterValues[i])
1681      );
1682    }
1683    thereExistsPricingState (
1684      operator,
1685      arrayAsList
1686    );
1687  }
1688
1689  public void orderByPricingState (
1690    short order
1691  ) {
1692    refAddValue(
1693      "org:opencrx:kernel:contract1:ContractPosition:pricingState",
1694      order
1695    );
1696  }
1697      
1698// ----------------------------------------------------------------------------
1699// Filter/ImplAttributeIsNotStruct
1700// ----------------------------------------------------------------------------
1701  public void forAllProductDescription (
1702    short operator,
1703    java.util.Collection   values
1704  ) {
1705    refAddValue(
1706      "org:opencrx:kernel:contract1:ContractPosition:productDescription",
1707      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1708      operator,
1709      values
1710    );
1711  }
1712
1713  public void thereExistsProductDescription (
1714    short operator,
1715    java.util.Collection   values
1716  ) {
1717    refAddValue(
1718      "org:opencrx:kernel:contract1:ContractPosition:productDescription",
1719      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1720      operator,
1721      values
1722    );
1723  }
1724
1725  public void forAllProductDescription (
1726    short operator,
1727    String  [] filterValues
1728  ) {
1729    java.util.List   arrayAsList = new java.util.ArrayList  ();
1730    for(int i = 0; i < filterValues.length; i++) {
1731      arrayAsList.add(
1732        filterValues[i]
1733      );
1734    }
1735    forAllProductDescription (
1736      operator,
1737      arrayAsList
1738    );
1739  }
1740
1741  public void thereExistsProductDescription (
1742    short operator,
1743    String  [] filterValues
1744  ) {
1745    java.util.List   arrayAsList = new java.util.ArrayList  ();
1746    for(int i = 0; i < filterValues.length; i++) {
1747      arrayAsList.add(
1748        filterValues[i]
1749      );
1750    }
1751    thereExistsProductDescription (
1752      operator,
1753      arrayAsList
1754    );
1755  }
1756
1757  public void orderByProductDescription (
1758    short order
1759  ) {
1760    refAddValue(
1761      "org:opencrx:kernel:contract1:ContractPosition:productDescription",
1762      order
1763    );
1764  }
1765      
1766// ----------------------------------------------------------------------------
1767// Filter/ImplAttributeIsNotStruct
1768// ----------------------------------------------------------------------------
1769  public void forAllProductDetailedDescription (
1770    short operator,
1771    java.util.Collection   values
1772  ) {
1773    refAddValue(
1774      "org:opencrx:kernel:contract1:ContractPosition:productDetailedDescription",
1775      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1776      operator,
1777      values
1778    );
1779  }
1780
1781  public void thereExistsProductDetailedDescription (
1782    short operator,
1783    java.util.Collection   values
1784  ) {
1785    refAddValue(
1786      "org:opencrx:kernel:contract1:ContractPosition:productDetailedDescription",
1787      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1788      operator,
1789      values
1790    );
1791  }
1792
1793  public void forAllProductDetailedDescription (
1794    short operator,
1795    String  [] filterValues
1796  ) {
1797    java.util.List   arrayAsList = new java.util.ArrayList  ();
1798    for(int i = 0; i < filterValues.length; i++) {
1799      arrayAsList.add(
1800        filterValues[i]
1801      );
1802    }
1803    forAllProductDetailedDescription (
1804      operator,
1805      arrayAsList
1806    );
1807  }
1808
1809  public void thereExistsProductDetailedDescription (
1810    short operator,
1811    String  [] filterValues
1812  ) {
1813    java.util.List   arrayAsList = new java.util.ArrayList  ();
1814    for(int i = 0; i < filterValues.length; i++) {
1815      arrayAsList.add(
1816        filterValues[i]
1817      );
1818    }
1819    thereExistsProductDetailedDescription (
1820      operator,
1821      arrayAsList
1822    );
1823  }
1824
1825  public void orderByProductDetailedDescription (
1826    short order
1827  ) {
1828    refAddValue(
1829      "org:opencrx:kernel:contract1:ContractPosition:productDetailedDescription",
1830      order
1831    );
1832  }
1833      
1834// ----------------------------------------------------------------------------
1835// Filter/ImplAttributeIsNotStruct
1836// ----------------------------------------------------------------------------
1837  public void forAllQuantity (
1838    short operator,
1839    java.util.Collection   values
1840  ) {
1841    refAddValue(
1842      "org:opencrx:kernel:contract1:ContractPosition:quantity",
1843      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1844      operator,
1845      values
1846    );
1847  }
1848
1849  public void thereExistsQuantity (
1850    short operator,
1851    java.util.Collection   values
1852  ) {
1853    refAddValue(
1854      "org:opencrx:kernel:contract1:ContractPosition:quantity",
1855      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1856      operator,
1857      values
1858    );
1859  }
1860
1861  public void forAllQuantity (
1862    short operator,
1863    java.math.BigDecimal  [] filterValues
1864  ) {
1865    java.util.List   arrayAsList = new java.util.ArrayList  ();
1866    for(int i = 0; i < filterValues.length; i++) {
1867      arrayAsList.add(
1868        filterValues[i]
1869      );
1870    }
1871    forAllQuantity (
1872      operator,
1873      arrayAsList
1874    );
1875  }
1876
1877  public void thereExistsQuantity (
1878    short operator,
1879    java.math.BigDecimal  [] filterValues
1880  ) {
1881    java.util.List   arrayAsList = new java.util.ArrayList  ();
1882    for(int i = 0; i < filterValues.length; i++) {
1883      arrayAsList.add(
1884        filterValues[i]
1885      );
1886    }
1887    thereExistsQuantity (
1888      operator,
1889      arrayAsList
1890    );
1891  }
1892
1893  public void orderByQuantity (
1894    short order
1895  ) {
1896    refAddValue(
1897      "org:opencrx:kernel:contract1:ContractPosition:quantity",
1898      order
1899    );
1900  }
1901      
1902// ----------------------------------------------------------------------------
1903// Filter/ImplAttributeIsNotStruct
1904// ----------------------------------------------------------------------------
1905  public void forAllQuantityBackOrdered (
1906    short operator,
1907    java.util.Collection   values
1908  ) {
1909    refAddValue(
1910      "org:opencrx:kernel:contract1:ContractPosition:quantityBackOrdered",
1911      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1912      operator,
1913      values
1914    );
1915  }
1916
1917  public void thereExistsQuantityBackOrdered (
1918    short operator,
1919    java.util.Collection   values
1920  ) {
1921    refAddValue(
1922      "org:opencrx:kernel:contract1:ContractPosition:quantityBackOrdered",
1923      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1924      operator,
1925      values
1926    );
1927  }
1928
1929  public void forAllQuantityBackOrdered (
1930    short operator,
1931    java.math.BigDecimal  [] filterValues
1932  ) {
1933    java.util.List   arrayAsList = new java.util.ArrayList  ();
1934    for(int i = 0; i < filterValues.length; i++) {
1935      arrayAsList.add(
1936        filterValues[i]
1937      );
1938    }
1939    forAllQuantityBackOrdered (
1940      operator,
1941      arrayAsList
1942    );
1943  }
1944
1945  public void thereExistsQuantityBackOrdered (
1946    short operator,
1947    java.math.BigDecimal  [] filterValues
1948  ) {
1949    java.util.List   arrayAsList = new java.util.ArrayList  ();
1950    for(int i = 0; i < filterValues.length; i++) {
1951      arrayAsList.add(
1952        filterValues[i]
1953      );
1954    }
1955    thereExistsQuantityBackOrdered (
1956      operator,
1957      arrayAsList
1958    );
1959  }
1960
1961  public void orderByQuantityBackOrdered (
1962    short order
1963  ) {
1964    refAddValue(
1965      "org:opencrx:kernel:contract1:ContractPosition:quantityBackOrdered",
1966      order
1967    );
1968  }
1969      
1970// ----------------------------------------------------------------------------
1971// Filter/ImplAttributeIsNotStruct
1972// ----------------------------------------------------------------------------
1973  public void forAllQuantityShipped (
1974    short operator,
1975    java.util.Collection   values
1976  ) {
1977    refAddValue(
1978      "org:opencrx:kernel:contract1:ContractPosition:quantityShipped",
1979      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1980      operator,
1981      values
1982    );
1983  }
1984
1985  public void thereExistsQuantityShipped (
1986    short operator,
1987    java.util.Collection   values
1988  ) {
1989    refAddValue(
1990      "org:opencrx:kernel:contract1:ContractPosition:quantityShipped",
1991      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1992      operator,
1993      values
1994    );
1995  }
1996
1997  public void forAllQuantityShipped (
1998    short operator,
1999    java.math.BigDecimal  [] filterValues
2000  ) {
2001    java.util.List   arrayAsList = new java.util.ArrayList  ();
2002    for(int i = 0; i < filterValues.length; i++) {
2003      arrayAsList.add(
2004        filterValues[i]
2005      );
2006    }
2007    forAllQuantityShipped (
2008      operator,
2009      arrayAsList
2010    );
2011  }
2012
2013  public void thereExistsQuantityShipped (
2014    short operator,
2015    java.math.BigDecimal  [] filterValues
2016  ) {
2017    java.util.List   arrayAsList = new java.util.ArrayList  ();
2018    for(int i = 0; i < filterValues.length; i++) {
2019      arrayAsList.add(
2020        filterValues[i]
2021      );
2022    }
2023    thereExistsQuantityShipped (
2024      operator,
2025      arrayAsList
2026    );
2027  }
2028
2029  public void orderByQuantityShipped (
2030    short order
2031  ) {
2032    refAddValue(
2033      "org:opencrx:kernel:contract1:ContractPosition:quantityShipped",
2034      order
2035    );
2036  }
2037      
2038// ----------------------------------------------------------------------------
2039// Filter/ImplAttributeIsNotStruct
2040// ----------------------------------------------------------------------------
2041  public void forAllSalesCommission (
2042    short operator,
2043    java.util.Collection   values
2044  ) {
2045    refAddValue(
2046      "org:opencrx:kernel:contract1:ContractPosition:salesCommission",
2047      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2048      operator,
2049      values
2050    );
2051  }
2052
2053  public void thereExistsSalesCommission (
2054    short operator,
2055    java.util.Collection   values
2056  ) {
2057    refAddValue(
2058      "org:opencrx:kernel:contract1:ContractPosition:salesCommission",
2059      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2060      operator,
2061      values
2062    );
2063  }
2064
2065  public void forAllSalesCommission (
2066    short operator,
2067    java.math.BigDecimal  [] filterValues
2068  ) {
2069    java.util.List   arrayAsList = new java.util.ArrayList  ();
2070    for(int i = 0; i < filterValues.length; i++) {
2071      arrayAsList.add(
2072        filterValues[i]
2073      );
2074    }
2075    forAllSalesCommission (
2076      operator,
2077      arrayAsList
2078    );
2079  }
2080
2081  public void thereExistsSalesCommission (
2082    short operator,
2083    java.math.BigDecimal  [] filterValues
2084  ) {
2085    java.util.List   arrayAsList = new java.util.ArrayList  ();
2086    for(int i = 0; i < filterValues.length; i++) {
2087      arrayAsList.add(
2088        filterValues[i]
2089      );
2090    }
2091    thereExistsSalesCommission (
2092      operator,
2093      arrayAsList
2094    );
2095  }
2096
2097  public void orderBySalesCommission (
2098    short order
2099  ) {
2100    refAddValue(
2101      "org:opencrx:kernel:contract1:ContractPosition:salesCommission",
2102      order
2103    );
2104  }
2105      
2106// ----------------------------------------------------------------------------
2107// Filter/ImplAttributeIsNotStruct
2108// ----------------------------------------------------------------------------
2109  public void forAllSalesCommissionIsPercentage (
2110    short operator,
2111    java.util.Collection   values
2112  ) {
2113    refAddValue(
2114      "org:opencrx:kernel:contract1:ContractPosition:salesCommissionIsPercentage",
2115      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2116      operator,
2117      values
2118    );
2119  }
2120
2121  public void thereExistsSalesCommissionIsPercentage (
2122    short operator,
2123    java.util.Collection   values
2124  ) {
2125    refAddValue(
2126      "org:opencrx:kernel:contract1:ContractPosition:salesCommissionIsPercentage",
2127      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2128      operator,
2129      values
2130    );
2131  }
2132
2133  public void forAllSalesCommissionIsPercentage (
2134    short operator,
2135    boolean[] filterValues
2136  ) {
2137    java.util.List   arrayAsList = new java.util.ArrayList  ();
2138    for(int i = 0; i < filterValues.length; i++) {
2139      arrayAsList.add(
2140        new Boolean  (filterValues[i])
2141      );
2142    }
2143    forAllSalesCommissionIsPercentage (
2144      operator,
2145      arrayAsList
2146    );
2147  }
2148
2149  public void thereExistsSalesCommissionIsPercentage (
2150    short operator,
2151    boolean[] filterValues
2152  ) {
2153    java.util.List   arrayAsList = new java.util.ArrayList  ();
2154    for(int i = 0; i < filterValues.length; i++) {
2155      arrayAsList.add(
2156        new Boolean  (filterValues[i])
2157      );
2158    }
2159    thereExistsSalesCommissionIsPercentage (
2160      operator,
2161      arrayAsList
2162    );
2163  }
2164
2165  public void orderBySalesCommissionIsPercentage (
2166    short order
2167  ) {
2168    refAddValue(
2169      "org:opencrx:kernel:contract1:ContractPosition:salesCommissionIsPercentage",
2170      order
2171    );
2172  }
2173      
2174// ----------------------------------------------------------------------------
2175// Filter/ImplReference
2176// ----------------------------------------------------------------------------
2177  public void forAllSalesTaxType (
2178    short operator,
2179    org.opencrx.kernel.product1.cci.SalesTaxType[] filterValues
2180  ) {
2181    java.util.List   arrayAsList = new java.util.ArrayList  ();
2182    for(int i = 0; i < filterValues.length; i++) {
2183      arrayAsList.add(
2184        filterValues[i]
2185      );
2186    }
2187    forAllSalesTaxType (
2188      operator,
2189      arrayAsList
2190    );
2191  }
2192
2193  public void thereExistsSalesTaxType (
2194    short operator,
2195    org.opencrx.kernel.product1.cci.SalesTaxType[] filterValues
2196  ) {
2197    java.util.List   arrayAsList = new java.util.ArrayList  ();
2198    for(int i = 0; i < filterValues.length; i++) {
2199      arrayAsList.add(
2200        filterValues[i]
2201      );
2202    }
2203    thereExistsSalesTaxType (
2204      operator,
2205      arrayAsList
2206    );
2207  }
2208
2209  public void forAllSalesTaxType (
2210    short operator,
2211    java.util.Collection   values
2212  ) {
2213    refAddValue(
2214      "org:opencrx:kernel:contract1:ContractPosition:salesTaxType",
2215      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2216      operator,
2217      values
2218    );
2219  }
2220
2221  public void thereExistsSalesTaxType (
2222    short operator,
2223    java.util.Collection   values
2224  ) {
2225    refAddValue(
2226      "org:opencrx:kernel:contract1:ContractPosition:salesTaxType",
2227      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2228      operator,
2229      values
2230    );
2231  }
2232      
2233// ----------------------------------------------------------------------------
2234// Filter/ImplAttributeIsNotStruct
2235// ----------------------------------------------------------------------------
2236  public void forAllSalesTaxTypeDescription (
2237    short operator,
2238    java.util.Collection   values
2239  ) {
2240    refAddValue(
2241      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDescription",
2242      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2243      operator,
2244      values
2245    );
2246  }
2247
2248  public void thereExistsSalesTaxTypeDescription (
2249    short operator,
2250    java.util.Collection   values
2251  ) {
2252    refAddValue(
2253      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDescription",
2254      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2255      operator,
2256      values
2257    );
2258  }
2259
2260  public void forAllSalesTaxTypeDescription (
2261    short operator,
2262    String  [] filterValues
2263  ) {
2264    java.util.List   arrayAsList = new java.util.ArrayList  ();
2265    for(int i = 0; i < filterValues.length; i++) {
2266      arrayAsList.add(
2267        filterValues[i]
2268      );
2269    }
2270    forAllSalesTaxTypeDescription (
2271      operator,
2272      arrayAsList
2273    );
2274  }
2275
2276  public void thereExistsSalesTaxTypeDescription (
2277    short operator,
2278    String  [] filterValues
2279  ) {
2280    java.util.List   arrayAsList = new java.util.ArrayList  ();
2281    for(int i = 0; i < filterValues.length; i++) {
2282      arrayAsList.add(
2283        filterValues[i]
2284      );
2285    }
2286    thereExistsSalesTaxTypeDescription (
2287      operator,
2288      arrayAsList
2289    );
2290  }
2291
2292  public void orderBySalesTaxTypeDescription (
2293    short order
2294  ) {
2295    refAddValue(
2296      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDescription",
2297      order
2298    );
2299  }
2300      
2301// ----------------------------------------------------------------------------
2302// Filter/ImplAttributeIsNotStruct
2303// ----------------------------------------------------------------------------
2304  public void forAllSalesTaxTypeDetailedDescription (
2305    short operator,
2306    java.util.Collection   values
2307  ) {
2308    refAddValue(
2309      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDetailedDescription",
2310      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2311      operator,
2312      values
2313    );
2314  }
2315
2316  public void thereExistsSalesTaxTypeDetailedDescription (
2317    short operator,
2318    java.util.Collection   values
2319  ) {
2320    refAddValue(
2321      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDetailedDescription",
2322      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2323      operator,
2324      values
2325    );
2326  }
2327
2328  public void forAllSalesTaxTypeDetailedDescription (
2329    short operator,
2330    String  [] filterValues
2331  ) {
2332    java.util.List   arrayAsList = new java.util.ArrayList  ();
2333    for(int i = 0; i < filterValues.length; i++) {
2334      arrayAsList.add(
2335        filterValues[i]
2336      );
2337    }
2338    forAllSalesTaxTypeDetailedDescription (
2339      operator,
2340      arrayAsList
2341    );
2342  }
2343
2344  public void thereExistsSalesTaxTypeDetailedDescription (
2345    short operator,
2346    String  [] filterValues
2347  ) {
2348    java.util.List   arrayAsList = new java.util.ArrayList  ();
2349    for(int i = 0; i < filterValues.length; i++) {
2350      arrayAsList.add(
2351        filterValues[i]
2352      );
2353    }
2354    thereExistsSalesTaxTypeDetailedDescription (
2355      operator,
2356      arrayAsList
2357    );
2358  }
2359
2360  public void orderBySalesTaxTypeDetailedDescription (
2361    short order
2362  ) {
2363    refAddValue(
2364      "org:opencrx:kernel:contract1:ContractPosition:salesTaxTypeDetailedDescription",
2365      order
2366    );
2367  }
2368      
2369// ----------------------------------------------------------------------------
2370// Filter/ImplAttributeIsNotStruct
2371// ----------------------------------------------------------------------------
2372  public void forAllTaxAmount (
2373    short operator,
2374    java.util.Collection   values
2375  ) {
2376    refAddValue(
2377      "org:opencrx:kernel:contract1:ContractPosition:taxAmount",
2378      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2379      operator,
2380      values
2381    );
2382  }
2383
2384  public void thereExistsTaxAmount (
2385    short operator,
2386    java.util.Collection   values
2387  ) {
2388    refAddValue(
2389      "org:opencrx:kernel:contract1:ContractPosition:taxAmount",
2390      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2391      operator,
2392      values
2393    );
2394  }
2395
2396  public void forAllTaxAmount (
2397    short operator,
2398    java.math.BigDecimal  [] filterValues
2399  ) {
2400    java.util.List   arrayAsList = new java.util.ArrayList  ();
2401    for(int i = 0; i < filterValues.length; i++) {
2402      arrayAsList.add(
2403        filterValues[i]
2404      );
2405    }
2406    forAllTaxAmount (
2407      operator,
2408      arrayAsList
2409    );
2410  }
2411
2412  public void thereExistsTaxAmount (
2413    short operator,
2414    java.math.BigDecimal  [] filterValues
2415  ) {
2416    java.util.List   arrayAsList = new java.util.ArrayList  ();
2417    for(int i = 0; i < filterValues.length; i++) {
2418      arrayAsList.add(
2419        filterValues[i]
2420      );
2421    }
2422    thereExistsTaxAmount (
2423      operator,
2424      arrayAsList
2425    );
2426  }
2427
2428  public void orderByTaxAmount (
2429    short order
2430  ) {
2431    refAddValue(
2432      "org:opencrx:kernel:contract1:ContractPosition:taxAmount",
2433      order
2434    );
2435  }
2436      
2437// ----------------------------------------------------------------------------
2438// Filter/ImplReference
2439// ----------------------------------------------------------------------------
2440  public void forAllUom (
2441    short operator,
2442    org.opencrx.kernel.uom1.cci.Uom[] filterValues
2443  ) {
2444    java.util.List   arrayAsList = new java.util.ArrayList  ();
2445    for(int i = 0; i < filterValues.length; i++) {
2446      arrayAsList.add(
2447        filterValues[i]
2448      );
2449    }
2450    forAllUom (
2451      operator,
2452      arrayAsList
2453    );
2454  }
2455
2456  public void thereExistsUom (
2457    short operator,
2458    org.opencrx.kernel.uom1.cci.Uom[] filterValues
2459  ) {
2460    java.util.List   arrayAsList = new java.util.ArrayList  ();
2461    for(int i = 0; i < filterValues.length; i++) {
2462      arrayAsList.add(
2463        filterValues[i]
2464      );
2465    }
2466    thereExistsUom (
2467      operator,
2468      arrayAsList
2469    );
2470  }
2471
2472  public void forAllUom (
2473    short operator,
2474    java.util.Collection   values
2475  ) {
2476    refAddValue(
2477      "org:opencrx:kernel:contract1:ContractPosition:uom",
2478      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2479      operator,
2480      values
2481    );
2482  }
2483
2484  public void thereExistsUom (
2485    short operator,
2486    java.util.Collection   values
2487  ) {
2488    refAddValue(
2489      "org:opencrx:kernel:contract1:ContractPosition:uom",
2490      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2491      operator,
2492      values
2493    );
2494  }
2495      
2496// ----------------------------------------------------------------------------
2497// Filter/ImplAttributeIsNotStruct
2498// ----------------------------------------------------------------------------
2499  public void forAllUomDescription (
2500    short operator,
2501    java.util.Collection   values
2502  ) {
2503    refAddValue(
2504      "org:opencrx:kernel:contract1:ContractPosition:uomDescription",
2505      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2506      operator,
2507      values
2508    );
2509  }
2510
2511  public void thereExistsUomDescription (
2512    short operator,
2513    java.util.Collection   values
2514  ) {
2515    refAddValue(
2516      "org:opencrx:kernel:contract1:ContractPosition:uomDescription",
2517      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2518      operator,
2519      values
2520    );
2521  }
2522
2523  public void forAllUomDescription (
2524    short operator,
2525    String  [] filterValues
2526  ) {
2527    java.util.List   arrayAsList = new java.util.ArrayList  ();
2528    for(int i = 0; i < filterValues.length; i++) {
2529      arrayAsList.add(
2530        filterValues[i]
2531      );
2532    }
2533    forAllUomDescription (
2534      operator,
2535      arrayAsList
2536    );
2537  }
2538
2539  public void thereExistsUomDescription (
2540    short operator,
2541    String  [] filterValues
2542  ) {
2543    java.util.List   arrayAsList = new java.util.ArrayList  ();
2544    for(int i = 0; i < filterValues.length; i++) {
2545      arrayAsList.add(
2546        filterValues[i]
2547      );
2548    }
2549    thereExistsUomDescription (
2550      operator,
2551      arrayAsList
2552    );
2553  }
2554
2555  public void orderByUomDescription (
2556    short order
2557  ) {
2558    refAddValue(
2559      "org:opencrx:kernel:contract1:ContractPosition:uomDescription",
2560      order
2561    );
2562  }
2563      
2564// ----------------------------------------------------------------------------
2565// Filter/ImplAttributeIsNotStruct
2566// ----------------------------------------------------------------------------
2567  public void forAllUomDetailedDescription (
2568    short operator,
2569    java.util.Collection   values
2570  ) {
2571    refAddValue(
2572      "org:opencrx:kernel:contract1:ContractPosition:uomDetailedDescription",
2573      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2574      operator,
2575      values
2576    );
2577  }
2578
2579  public void thereExistsUomDetailedDescription (
2580    short operator,
2581    java.util.Collection   values
2582  ) {
2583    refAddValue(
2584      "org:opencrx:kernel:contract1:ContractPosition:uomDetailedDescription",
2585      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2586      operator,
2587      values
2588    );
2589  }
2590
2591  public void forAllUomDetailedDescription (
2592    short operator,
2593    String  [] filterValues
2594  ) {
2595    java.util.List   arrayAsList = new java.util.ArrayList  ();
2596    for(int i = 0; i < filterValues.length; i++) {
2597      arrayAsList.add(
2598        filterValues[i]
2599      );
2600    }
2601    forAllUomDetailedDescription (
2602      operator,
2603      arrayAsList
2604    );
2605  }
2606
2607  public void thereExistsUomDetailedDescription (
2608    short operator,
2609    String  [] filterValues
2610  ) {
2611    java.util.List   arrayAsList = new java.util.ArrayList  ();
2612    for(int i = 0; i < filterValues.length; i++) {
2613      arrayAsList.add(
2614        filterValues[i]
2615      );
2616    }
2617    thereExistsUomDetailedDescription (
2618      operator,
2619      arrayAsList
2620    );
2621  }
2622
2623  public void orderByUomDetailedDescription (
2624    short order
2625  ) {
2626    refAddValue(
2627      "org:opencrx:kernel:contract1:ContractPosition:uomDetailedDescription",
2628      order
2629    );
2630  }
2631      
2632// ----------------------------------------------------------------------------
2633// Filter/ImplReference
2634// ----------------------------------------------------------------------------
2635  public void forAllCarrier (
2636    short operator,
2637    org.opencrx.kernel.account1.cci.Account[] filterValues
2638  ) {
2639    java.util.List   arrayAsList = new java.util.ArrayList  ();
2640    for(int i = 0; i < filterValues.length; i++) {
2641      arrayAsList.add(
2642        filterValues[i]
2643      );
2644    }
2645    forAllCarrier (
2646      operator,
2647      arrayAsList
2648    );
2649  }
2650
2651  public void thereExistsCarrier (
2652    short operator,
2653    org.opencrx.kernel.account1.cci.Account[] filterValues
2654  ) {
2655    java.util.List   arrayAsList = new java.util.ArrayList  ();
2656    for(int i = 0; i < filterValues.length; i++) {
2657      arrayAsList.add(
2658        filterValues[i]
2659      );
2660    }
2661    thereExistsCarrier (
2662      operator,
2663      arrayAsList
2664    );
2665  }
2666
2667  public void forAllCarrier (
2668    short operator,
2669    java.util.Collection   values
2670  ) {
2671    refAddValue(
2672      "org:opencrx:kernel:contract1:ShippingDetail:carrier",
2673      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2674      operator,
2675      values
2676    );
2677  }
2678
2679  public void thereExistsCarrier (
2680    short operator,
2681    java.util.Collection   values
2682  ) {
2683    refAddValue(
2684      "org:opencrx:kernel:contract1:ShippingDetail:carrier",
2685      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2686      operator,
2687      values
2688    );
2689  }
2690      
2691// ----------------------------------------------------------------------------
2692// Filter/ImplAttributeIsNotStruct
2693// ----------------------------------------------------------------------------
2694  public void forAllGiftMessage (
2695    short operator,
2696    java.util.Collection   values
2697  ) {
2698    refAddValue(
2699      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2700      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2701      operator,
2702      values
2703    );
2704  }
2705
2706  public void thereExistsGiftMessage (
2707    short operator,
2708    java.util.Collection   values
2709  ) {
2710    refAddValue(
2711      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2712      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2713      operator,
2714      values
2715    );
2716  }
2717
2718  public void forAllGiftMessage (
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    forAllGiftMessage (
2729      operator,
2730      arrayAsList
2731    );
2732  }
2733
2734  public void thereExistsGiftMessage (
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    thereExistsGiftMessage (
2745      operator,
2746      arrayAsList
2747    );
2748  }
2749
2750  public void orderByGiftMessage (
2751    short order
2752  ) {
2753    refAddValue(
2754      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2755      order
2756    );
2757  }
2758      
2759// ----------------------------------------------------------------------------
2760// Filter/ImplAttributeIsNotStruct
2761// ----------------------------------------------------------------------------
2762  public void forAllIsGift (
2763    short operator,
2764    java.util.Collection   values
2765  ) {
2766    refAddValue(
2767      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2768      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2769      operator,
2770      values
2771    );
2772  }
2773
2774  public void thereExistsIsGift (
2775    short operator,
2776    java.util.Collection   values
2777  ) {
2778    refAddValue(
2779      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2780      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2781      operator,
2782      values
2783    );
2784  }
2785
2786  public void forAllIsGift (
2787    short operator,
2788    boolean[] filterValues
2789  ) {
2790    java.util.List   arrayAsList = new java.util.ArrayList  ();
2791    for(int i = 0; i < filterValues.length; i++) {
2792      arrayAsList.add(
2793        new Boolean  (filterValues[i])
2794      );
2795    }
2796    forAllIsGift (
2797      operator,
2798      arrayAsList
2799    );
2800  }
2801
2802  public void thereExistsIsGift (
2803    short operator,
2804    boolean[] filterValues
2805  ) {
2806    java.util.List   arrayAsList = new java.util.ArrayList  ();
2807    for(int i = 0; i < filterValues.length; i++) {
2808      arrayAsList.add(
2809        new Boolean  (filterValues[i])
2810      );
2811    }
2812    thereExistsIsGift (
2813      operator,
2814      arrayAsList
2815    );
2816  }
2817
2818  public void orderByIsGift (
2819    short order
2820  ) {
2821    refAddValue(
2822      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2823      order
2824    );
2825  }
2826      
2827// ----------------------------------------------------------------------------
2828// Filter/ImplAttributeIsNotStruct
2829// ----------------------------------------------------------------------------
2830  public void forAllShippingInstructions (
2831    short operator,
2832    java.util.Collection   values
2833  ) {
2834    refAddValue(
2835      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2836      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2837      operator,
2838      values
2839    );
2840  }
2841
2842  public void thereExistsShippingInstructions (
2843    short operator,
2844    java.util.Collection   values
2845  ) {
2846    refAddValue(
2847      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2848      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2849      operator,
2850      values
2851    );
2852  }
2853
2854  public void forAllShippingInstructions (
2855    short operator,
2856    String  [] filterValues
2857  ) {
2858    java.util.List   arrayAsList = new java.util.ArrayList  ();
2859    for(int i = 0; i < filterValues.length; i++) {
2860      arrayAsList.add(
2861        filterValues[i]
2862      );
2863    }
2864    forAllShippingInstructions (
2865      operator,
2866      arrayAsList
2867    );
2868  }
2869
2870  public void thereExistsShippingInstructions (
2871    short operator,
2872    String  [] filterValues
2873  ) {
2874    java.util.List   arrayAsList = new java.util.ArrayList  ();
2875    for(int i = 0; i < filterValues.length; i++) {
2876      arrayAsList.add(
2877        filterValues[i]
2878      );
2879    }
2880    thereExistsShippingInstructions (
2881      operator,
2882      arrayAsList
2883    );
2884  }
2885
2886  public void orderByShippingInstructions (
2887    short order
2888  ) {
2889    refAddValue(
2890      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2891      order
2892    );
2893  }
2894      
2895// ----------------------------------------------------------------------------
2896// Filter/ImplAttributeIsNotStruct
2897// ----------------------------------------------------------------------------
2898  public void forAllShippingMethod (
2899    short operator,
2900    java.util.Collection   values
2901  ) {
2902    refAddValue(
2903      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2904      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2905      operator,
2906      values
2907    );
2908  }
2909
2910  public void thereExistsShippingMethod (
2911    short operator,
2912    java.util.Collection   values
2913  ) {
2914    refAddValue(
2915      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2916      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2917      operator,
2918      values
2919    );
2920  }
2921
2922  public void forAllShippingMethod (
2923    short operator,
2924    short[] filterValues
2925  ) {
2926    java.util.List   arrayAsList = new java.util.ArrayList  ();
2927    for(int i = 0; i < filterValues.length; i++) {
2928      arrayAsList.add(
2929        new Short  (filterValues[i])
2930      );
2931    }
2932    forAllShippingMethod (
2933      operator,
2934      arrayAsList
2935    );
2936  }
2937
2938  public void thereExistsShippingMethod (
2939    short operator,
2940    short[] filterValues
2941  ) {
2942    java.util.List   arrayAsList = new java.util.ArrayList  ();
2943    for(int i = 0; i < filterValues.length; i++) {
2944      arrayAsList.add(
2945        new Short  (filterValues[i])
2946      );
2947    }
2948    thereExistsShippingMethod (
2949      operator,
2950      arrayAsList
2951    );
2952  }
2953
2954  public void orderByShippingMethod (
2955    short order
2956  ) {
2957    refAddValue(
2958      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2959      order
2960    );
2961  }
2962      
2963// ----------------------------------------------------------------------------
2964// Filter/ImplAttributeIsNotStruct
2965// ----------------------------------------------------------------------------
2966  public void forAllShippingTrackingNumber (
2967    short operator,
2968    java.util.Collection   values
2969  ) {
2970    refAddValue(
2971      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
2972      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2973      operator,
2974      values
2975    );
2976  }
2977
2978  public void thereExistsShippingTrackingNumber (
2979    short operator,
2980    java.util.Collection   values
2981  ) {
2982    refAddValue(
2983      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
2984      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2985      operator,
2986      values
2987    );
2988  }
2989
2990  public void forAllShippingTrackingNumber (
2991    short operator,
2992    String  [] filterValues
2993  ) {
2994    java.util.List   arrayAsList = new java.util.ArrayList  ();
2995    for(int i = 0; i < filterValues.length; i++) {
2996      arrayAsList.add(
2997        filterValues[i]
2998      );
2999    }
3000    forAllShippingTrackingNumber (
3001      operator,
3002      arrayAsList
3003    );
3004  }
3005
3006  public void thereExistsShippingTrackingNumber (
3007    short operator,
3008    String  [] filterValues
3009  ) {
3010    java.util.List   arrayAsList = new java.util.ArrayList  ();
3011    for(int i = 0; i < filterValues.length; i++) {
3012      arrayAsList.add(
3013        filterValues[i]
3014      );
3015    }
3016    thereExistsShippingTrackingNumber (
3017      operator,
3018      arrayAsList
3019    );
3020  }
3021
3022  public void orderByShippingTrackingNumber (
3023    short order
3024  ) {
3025    refAddValue(
3026      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
3027      order
3028    );
3029  }
3030      
3031// ----------------------------------------------------------------------------
3032// Filter/ImplEnd
3033// ----------------------------------------------------------------------------
3034}        
3035
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags