KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencrx > kernel > contract1 > cci > AbstractContractFilterImpl


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 AbstractContractFilterImpl
16   extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17   implements AbstractContractFilter {
18
19   public AbstractContractFilterImpl(
20     org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21   ) {
22     super(
23       aPackage,
24       "org:opencrx:kernel:contract1:AbstractContract",
25       null,
26       null
27     );
28   }
29
30   public AbstractContractFilterImpl(
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:AbstractContract",
38       filterProperties,
39       attributeSpecifiers
40     );
41   }
42       
43 // ----------------------------------------------------------------------------
44
// Filter/ImplAttributeIsNotStruct
45
// ----------------------------------------------------------------------------
46
public void forAllIsTemplate (
47     short operator,
48     java.util.Collection JavaDoc values
49   ) {
50     refAddValue(
51       "org:opencrx:kernel:base:TemplateEnabled:isTemplate",
52       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53       operator,
54       values
55     );
56   }
57
58   public void thereExistsIsTemplate (
59     short operator,
60     java.util.Collection JavaDoc values
61   ) {
62     refAddValue(
63       "org:opencrx:kernel:base:TemplateEnabled:isTemplate",
64       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65       operator,
66       values
67     );
68   }
69
70   public void forAllIsTemplate (
71     short operator,
72     boolean[] filterValues
73   ) {
74     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
75     for(int i = 0; i < filterValues.length; i++) {
76       arrayAsList.add(
77         new Boolean JavaDoc(filterValues[i])
78       );
79     }
80     forAllIsTemplate (
81       operator,
82       arrayAsList
83     );
84   }
85
86   public void thereExistsIsTemplate (
87     short operator,
88     boolean[] filterValues
89   ) {
90     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
91     for(int i = 0; i < filterValues.length; i++) {
92       arrayAsList.add(
93         new Boolean JavaDoc(filterValues[i])
94       );
95     }
96     thereExistsIsTemplate (
97       operator,
98       arrayAsList
99     );
100   }
101
102   public void orderByIsTemplate (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:base:TemplateEnabled:isTemplate",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112
// Filter/ImplAttributeIsNotStruct
113
// ----------------------------------------------------------------------------
114
public void forAllTemplateReferenceFilter (
115     short operator,
116     java.util.Collection JavaDoc values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:base:TemplateEnabled:templateReferenceFilter",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125
126   public void thereExistsTemplateReferenceFilter (
127     short operator,
128     java.util.Collection JavaDoc values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:base:TemplateEnabled:templateReferenceFilter",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137
138   public void forAllTemplateReferenceFilter (
139     short operator,
140     String JavaDoc[] filterValues
141   ) {
142     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
143     for(int i = 0; i < filterValues.length; i++) {
144       arrayAsList.add(
145         filterValues[i]
146       );
147     }
148     forAllTemplateReferenceFilter (
149       operator,
150       arrayAsList
151     );
152   }
153
154   public void thereExistsTemplateReferenceFilter (
155     short operator,
156     String JavaDoc[] filterValues
157   ) {
158     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
159     for(int i = 0; i < filterValues.length; i++) {
160       arrayAsList.add(
161         filterValues[i]
162       );
163     }
164     thereExistsTemplateReferenceFilter (
165       operator,
166       arrayAsList
167     );
168   }
169
170   public void orderByTemplateReferenceFilter (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:base:TemplateEnabled:templateReferenceFilter",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180
// Filter/ImplAttributeIsNotStruct
181
// ----------------------------------------------------------------------------
182
public void forAllActiveOn (
183     short operator,
184     java.util.Collection JavaDoc values
185   ) {
186     refAddValue(
187       "org:opencrx:kernel:contract1:AbstractContract:activeOn",
188       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
189       operator,
190       values
191     );
192   }
193
194   public void thereExistsActiveOn (
195     short operator,
196     java.util.Collection JavaDoc values
197   ) {
198     refAddValue(
199       "org:opencrx:kernel:contract1:AbstractContract:activeOn",
200       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
201       operator,
202       values
203     );
204   }
205
206   public void forAllActiveOn (
207     short operator,
208     java.util.Date JavaDoc[] filterValues
209   ) {
210     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
211     for(int i = 0; i < filterValues.length; i++) {
212       arrayAsList.add(
213         filterValues[i]
214       );
215     }
216     forAllActiveOn (
217       operator,
218       arrayAsList
219     );
220   }
221
222   public void thereExistsActiveOn (
223     short operator,
224     java.util.Date JavaDoc[] filterValues
225   ) {
226     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
227     for(int i = 0; i < filterValues.length; i++) {
228       arrayAsList.add(
229         filterValues[i]
230       );
231     }
232     thereExistsActiveOn (
233       operator,
234       arrayAsList
235     );
236   }
237
238   public void orderByActiveOn (
239     short order
240   ) {
241     refAddValue(
242       "org:opencrx:kernel:contract1:AbstractContract:activeOn",
243       order
244     );
245   }
246       
247 // ----------------------------------------------------------------------------
248
// Filter/ImplReference
249
// ----------------------------------------------------------------------------
250
public void forAllActivity (
251     short operator,
252     org.opencrx.kernel.activity1.cci.Activity[] filterValues
253   ) {
254     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
255     for(int i = 0; i < filterValues.length; i++) {
256       arrayAsList.add(
257         filterValues[i]
258       );
259     }
260     forAllActivity (
261       operator,
262       arrayAsList
263     );
264   }
265
266   public void thereExistsActivity (
267     short operator,
268     org.opencrx.kernel.activity1.cci.Activity[] filterValues
269   ) {
270     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
271     for(int i = 0; i < filterValues.length; i++) {
272       arrayAsList.add(
273         filterValues[i]
274       );
275     }
276     thereExistsActivity (
277       operator,
278       arrayAsList
279     );
280   }
281
282   public void forAllActivity (
283     short operator,
284     java.util.Collection JavaDoc values
285   ) {
286     refAddValue(
287       "org:opencrx:kernel:contract1:AbstractContract:activity",
288       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
289       operator,
290       values
291     );
292   }
293
294   public void thereExistsActivity (
295     short operator,
296     java.util.Collection JavaDoc values
297   ) {
298     refAddValue(
299       "org:opencrx:kernel:contract1:AbstractContract:activity",
300       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
301       operator,
302       values
303     );
304   }
305       
306 // ----------------------------------------------------------------------------
307
// Filter/ImplReference
308
// ----------------------------------------------------------------------------
309
public void forAllBroker (
310     short operator,
311     org.opencrx.kernel.account1.cci.Account[] filterValues
312   ) {
313     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
314     for(int i = 0; i < filterValues.length; i++) {
315       arrayAsList.add(
316         filterValues[i]
317       );
318     }
319     forAllBroker (
320       operator,
321       arrayAsList
322     );
323   }
324
325   public void thereExistsBroker (
326     short operator,
327     org.opencrx.kernel.account1.cci.Account[] filterValues
328   ) {
329     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
330     for(int i = 0; i < filterValues.length; i++) {
331       arrayAsList.add(
332         filterValues[i]
333       );
334     }
335     thereExistsBroker (
336       operator,
337       arrayAsList
338     );
339   }
340
341   public void forAllBroker (
342     short operator,
343     java.util.Collection JavaDoc values
344   ) {
345     refAddValue(
346       "org:opencrx:kernel:contract1:AbstractContract:broker",
347       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
348       operator,
349       values
350     );
351   }
352
353   public void thereExistsBroker (
354     short operator,
355     java.util.Collection JavaDoc values
356   ) {
357     refAddValue(
358       "org:opencrx:kernel:contract1:AbstractContract:broker",
359       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
360       operator,
361       values
362     );
363   }
364       
365 // ----------------------------------------------------------------------------
366
// Filter/ImplAttributeIsNotStruct
367
// ----------------------------------------------------------------------------
368
public void forAllCancelOn (
369     short operator,
370     java.util.Collection JavaDoc values
371   ) {
372     refAddValue(
373       "org:opencrx:kernel:contract1:AbstractContract:cancelOn",
374       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
375       operator,
376       values
377     );
378   }
379
380   public void thereExistsCancelOn (
381     short operator,
382     java.util.Collection JavaDoc values
383   ) {
384     refAddValue(
385       "org:opencrx:kernel:contract1:AbstractContract:cancelOn",
386       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
387       operator,
388       values
389     );
390   }
391
392   public void forAllCancelOn (
393     short operator,
394     java.util.Date JavaDoc[] filterValues
395   ) {
396     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
397     for(int i = 0; i < filterValues.length; i++) {
398       arrayAsList.add(
399         filterValues[i]
400       );
401     }
402     forAllCancelOn (
403       operator,
404       arrayAsList
405     );
406   }
407
408   public void thereExistsCancelOn (
409     short operator,
410     java.util.Date JavaDoc[] filterValues
411   ) {
412     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
413     for(int i = 0; i < filterValues.length; i++) {
414       arrayAsList.add(
415         filterValues[i]
416       );
417     }
418     thereExistsCancelOn (
419       operator,
420       arrayAsList
421     );
422   }
423
424   public void orderByCancelOn (
425     short order
426   ) {
427     refAddValue(
428       "org:opencrx:kernel:contract1:AbstractContract:cancelOn",
429       order
430     );
431   }
432       
433 // ----------------------------------------------------------------------------
434
// Filter/ImplAttributeIsNotStruct
435
// ----------------------------------------------------------------------------
436
public void forAllClosedOn (
437     short operator,
438     java.util.Collection JavaDoc values
439   ) {
440     refAddValue(
441       "org:opencrx:kernel:contract1:AbstractContract:closedOn",
442       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
443       operator,
444       values
445     );
446   }
447
448   public void thereExistsClosedOn (
449     short operator,
450     java.util.Collection JavaDoc values
451   ) {
452     refAddValue(
453       "org:opencrx:kernel:contract1:AbstractContract:closedOn",
454       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
455       operator,
456       values
457     );
458   }
459
460   public void forAllClosedOn (
461     short operator,
462     java.util.Date JavaDoc[] filterValues
463   ) {
464     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
465     for(int i = 0; i < filterValues.length; i++) {
466       arrayAsList.add(
467         filterValues[i]
468       );
469     }
470     forAllClosedOn (
471       operator,
472       arrayAsList
473     );
474   }
475
476   public void thereExistsClosedOn (
477     short operator,
478     java.util.Date JavaDoc[] filterValues
479   ) {
480     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
481     for(int i = 0; i < filterValues.length; i++) {
482       arrayAsList.add(
483         filterValues[i]
484       );
485     }
486     thereExistsClosedOn (
487       operator,
488       arrayAsList
489     );
490   }
491
492   public void orderByClosedOn (
493     short order
494   ) {
495     refAddValue(
496       "org:opencrx:kernel:contract1:AbstractContract:closedOn",
497       order
498     );
499   }
500       
501 // ----------------------------------------------------------------------------
502
// Filter/ImplReference
503
// ----------------------------------------------------------------------------
504
public void forAllCompetitor (
505     short operator,
506     org.opencrx.kernel.account1.cci.Competitor[] filterValues
507   ) {
508     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
509     for(int i = 0; i < filterValues.length; i++) {
510       arrayAsList.add(
511         filterValues[i]
512       );
513     }
514     forAllCompetitor (
515       operator,
516       arrayAsList
517     );
518   }
519
520   public void thereExistsCompetitor (
521     short operator,
522     org.opencrx.kernel.account1.cci.Competitor[] filterValues
523   ) {
524     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
525     for(int i = 0; i < filterValues.length; i++) {
526       arrayAsList.add(
527         filterValues[i]
528       );
529     }
530     thereExistsCompetitor (
531       operator,
532       arrayAsList
533     );
534   }
535
536   public void forAllCompetitor (
537     short operator,
538     java.util.Collection JavaDoc values
539   ) {
540     refAddValue(
541       "org:opencrx:kernel:contract1:AbstractContract:competitor",
542       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
543       operator,
544       values
545     );
546   }
547
548   public void thereExistsCompetitor (
549     short operator,
550     java.util.Collection JavaDoc values
551   ) {
552     refAddValue(
553       "org:opencrx:kernel:contract1:AbstractContract:competitor",
554       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
555       operator,
556       values
557     );
558   }
559       
560 // ----------------------------------------------------------------------------
561
// Filter/ImplReference
562
// ----------------------------------------------------------------------------
563
public void forAllContact (
564     short operator,
565     org.opencrx.kernel.account1.cci.Contact[] filterValues
566   ) {
567     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
568     for(int i = 0; i < filterValues.length; i++) {
569       arrayAsList.add(
570         filterValues[i]
571       );
572     }
573     forAllContact (
574       operator,
575       arrayAsList
576     );
577   }
578
579   public void thereExistsContact (
580     short operator,
581     org.opencrx.kernel.account1.cci.Contact[] filterValues
582   ) {
583     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
584     for(int i = 0; i < filterValues.length; i++) {
585       arrayAsList.add(
586         filterValues[i]
587       );
588     }
589     thereExistsContact (
590       operator,
591       arrayAsList
592     );
593   }
594
595   public void forAllContact (
596     short operator,
597     java.util.Collection JavaDoc values
598   ) {
599     refAddValue(
600       "org:opencrx:kernel:contract1:AbstractContract:contact",
601       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
602       operator,
603       values
604     );
605   }
606
607   public void thereExistsContact (
608     short operator,
609     java.util.Collection JavaDoc values
610   ) {
611     refAddValue(
612       "org:opencrx:kernel:contract1:AbstractContract:contact",
613       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
614       operator,
615       values
616     );
617   }
618       
619 // ----------------------------------------------------------------------------
620
// Filter/ImplAttributeIsNotStruct
621
// ----------------------------------------------------------------------------
622
public void forAllContractCurrency (
623     short operator,
624     java.util.Collection JavaDoc values
625   ) {
626     refAddValue(
627       "org:opencrx:kernel:contract1:AbstractContract:contractCurrency",
628       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
629       operator,
630       values
631     );
632   }
633
634   public void thereExistsContractCurrency (
635     short operator,
636     java.util.Collection JavaDoc values
637   ) {
638     refAddValue(
639       "org:opencrx:kernel:contract1:AbstractContract:contractCurrency",
640       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
641       operator,
642       values
643     );
644   }
645
646   public void forAllContractCurrency (
647     short operator,
648     short[] filterValues
649   ) {
650     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
651     for(int i = 0; i < filterValues.length; i++) {
652       arrayAsList.add(
653         new Short JavaDoc(filterValues[i])
654       );
655     }
656     forAllContractCurrency (
657       operator,
658       arrayAsList
659     );
660   }
661
662   public void thereExistsContractCurrency (
663     short operator,
664     short[] filterValues
665   ) {
666     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
667     for(int i = 0; i < filterValues.length; i++) {
668       arrayAsList.add(
669         new Short JavaDoc(filterValues[i])
670       );
671     }
672     thereExistsContractCurrency (
673       operator,
674       arrayAsList
675     );
676   }
677
678   public void orderByContractCurrency (
679     short order
680   ) {
681     refAddValue(
682       "org:opencrx:kernel:contract1:AbstractContract:contractCurrency",
683       order
684     );
685   }
686       
687 // ----------------------------------------------------------------------------
688
// Filter/ImplAttributeIsNotStruct
689
// ----------------------------------------------------------------------------
690
public void forAllContractLanguage (
691     short operator,
692     java.util.Collection JavaDoc values
693   ) {
694     refAddValue(
695       "org:opencrx:kernel:contract1:AbstractContract:contractLanguage",
696       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
697       operator,
698       values
699     );
700   }
701
702   public void thereExistsContractLanguage (
703     short operator,
704     java.util.Collection JavaDoc values
705   ) {
706     refAddValue(
707       "org:opencrx:kernel:contract1:AbstractContract:contractLanguage",
708       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
709       operator,
710       values
711     );
712   }
713
714   public void forAllContractLanguage (
715     short operator,
716     short[] filterValues
717   ) {
718     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
719     for(int i = 0; i < filterValues.length; i++) {
720       arrayAsList.add(
721         new Short JavaDoc(filterValues[i])
722       );
723     }
724     forAllContractLanguage (
725       operator,
726       arrayAsList
727     );
728   }
729
730   public void thereExistsContractLanguage (
731     short operator,
732     short[] filterValues
733   ) {
734     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
735     for(int i = 0; i < filterValues.length; i++) {
736       arrayAsList.add(
737         new Short JavaDoc(filterValues[i])
738       );
739     }
740     thereExistsContractLanguage (
741       operator,
742       arrayAsList
743     );
744   }
745
746   public void orderByContractLanguage (
747     short order
748   ) {
749     refAddValue(
750       "org:opencrx:kernel:contract1:AbstractContract:contractLanguage",
751       order
752     );
753   }
754       
755 // ----------------------------------------------------------------------------
756
// Filter/ImplAttributeIsNotStruct
757
// ----------------------------------------------------------------------------
758
public void forAllContractNumber (
759     short operator,
760     java.util.Collection JavaDoc values
761   ) {
762     refAddValue(
763       "org:opencrx:kernel:contract1:AbstractContract:contractNumber",
764       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
765       operator,
766       values
767     );
768   }
769
770   public void thereExistsContractNumber (
771     short operator,
772     java.util.Collection JavaDoc values
773   ) {
774     refAddValue(
775       "org:opencrx:kernel:contract1:AbstractContract:contractNumber",
776       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
777       operator,
778       values
779     );
780   }
781
782   public void forAllContractNumber (
783     short operator,
784     String JavaDoc[] filterValues
785   ) {
786     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
787     for(int i = 0; i < filterValues.length; i++) {
788       arrayAsList.add(
789         filterValues[i]
790       );
791     }
792     forAllContractNumber (
793       operator,
794       arrayAsList
795     );
796   }
797
798   public void thereExistsContractNumber (
799     short operator,
800     String JavaDoc[] filterValues
801   ) {
802     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
803     for(int i = 0; i < filterValues.length; i++) {
804       arrayAsList.add(
805         filterValues[i]
806       );
807     }
808     thereExistsContractNumber (
809       operator,
810       arrayAsList
811     );
812   }
813
814   public void orderByContractNumber (
815     short order
816   ) {
817     refAddValue(
818       "org:opencrx:kernel:contract1:AbstractContract:contractNumber",
819       order
820     );
821   }
822       
823 // ----------------------------------------------------------------------------
824
// Filter/ImplAttributeIsNotStruct
825
// ----------------------------------------------------------------------------
826
public void forAllContractState (
827     short operator,
828     java.util.Collection JavaDoc values
829   ) {
830     refAddValue(
831       "org:opencrx:kernel:contract1:AbstractContract:contractState",
832       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
833       operator,
834       values
835     );
836   }
837
838   public void thereExistsContractState (
839     short operator,
840     java.util.Collection JavaDoc values
841   ) {
842     refAddValue(
843       "org:opencrx:kernel:contract1:AbstractContract:contractState",
844       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
845       operator,
846       values
847     );
848   }
849
850   public void forAllContractState (
851     short operator,
852     short[] filterValues
853   ) {
854     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
855     for(int i = 0; i < filterValues.length; i++) {
856       arrayAsList.add(
857         new Short JavaDoc(filterValues[i])
858       );
859     }
860     forAllContractState (
861       operator,
862       arrayAsList
863     );
864   }
865
866   public void thereExistsContractState (
867     short operator,
868     short[] filterValues
869   ) {
870     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
871     for(int i = 0; i < filterValues.length; i++) {
872       arrayAsList.add(
873         new Short JavaDoc(filterValues[i])
874       );
875     }
876     thereExistsContractState (
877       operator,
878       arrayAsList
879     );
880   }
881
882   public void orderByContractState (
883     short order
884   ) {
885     refAddValue(
886       "org:opencrx:kernel:contract1:AbstractContract:contractState",
887       order
888     );
889   }
890       
891 // ----------------------------------------------------------------------------
892
// Filter/ImplReference
893
// ----------------------------------------------------------------------------
894
public void forAllCustomer (
895     short operator,
896     org.opencrx.kernel.account1.cci.Account[] filterValues
897   ) {
898     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
899     for(int i = 0; i < filterValues.length; i++) {
900       arrayAsList.add(
901         filterValues[i]
902       );
903     }
904     forAllCustomer (
905       operator,
906       arrayAsList
907     );
908   }
909
910   public void thereExistsCustomer (
911     short operator,
912     org.opencrx.kernel.account1.cci.Account[] filterValues
913   ) {
914     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
915     for(int i = 0; i < filterValues.length; i++) {
916       arrayAsList.add(
917         filterValues[i]
918       );
919     }
920     thereExistsCustomer (
921       operator,
922       arrayAsList
923     );
924   }
925
926   public void forAllCustomer (
927     short operator,
928     java.util.Collection JavaDoc values
929   ) {
930     refAddValue(
931       "org:opencrx:kernel:contract1:AbstractContract:customer",
932       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
933       operator,
934       values
935     );
936   }
937
938   public void thereExistsCustomer (
939     short operator,
940     java.util.Collection JavaDoc values
941   ) {
942     refAddValue(
943       "org:opencrx:kernel:contract1:AbstractContract:customer",
944       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
945       operator,
946       values
947     );
948   }
949       
950 // ----------------------------------------------------------------------------
951
// Filter/ImplAttributeIsNotStruct
952
// ----------------------------------------------------------------------------
953
public void forAllDescription (
954     short operator,
955     java.util.Collection JavaDoc values
956   ) {
957     refAddValue(
958       "org:opencrx:kernel:contract1:AbstractContract:description",
959       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
960       operator,
961       values
962     );
963   }
964
965   public void thereExistsDescription (
966     short operator,
967     java.util.Collection JavaDoc values
968   ) {
969     refAddValue(
970       "org:opencrx:kernel:contract1:AbstractContract:description",
971       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
972       operator,
973       values
974     );
975   }
976
977   public void forAllDescription (
978     short operator,
979     String JavaDoc[] filterValues
980   ) {
981     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
982     for(int i = 0; i < filterValues.length; i++) {
983       arrayAsList.add(
984         filterValues[i]
985       );
986     }
987     forAllDescription (
988       operator,
989       arrayAsList
990     );
991   }
992
993   public void thereExistsDescription (
994     short operator,
995     String JavaDoc[] filterValues
996   ) {
997     java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
998     for(int i = 0; i < filterValues.length; i++) {
999       arrayAsList.add(
1000        filterValues[i]
1001      );
1002    }
1003    thereExistsDescription (
1004      operator,
1005      arrayAsList
1006    );
1007  }
1008
1009  public void orderByDescription (
1010    short order
1011  ) {
1012    refAddValue(
1013      "org:opencrx:kernel:contract1:AbstractContract:description",
1014      order
1015    );
1016  }
1017      
1018// ----------------------------------------------------------------------------
1019
// Filter/ImplAttributeIsNotStruct
1020
// ----------------------------------------------------------------------------
1021
public void forAllExpiresOn (
1022    short operator,
1023    java.util.Collection JavaDoc values
1024  ) {
1025    refAddValue(
1026      "org:opencrx:kernel:contract1:AbstractContract:expiresOn",
1027      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1028      operator,
1029      values
1030    );
1031  }
1032
1033  public void thereExistsExpiresOn (
1034    short operator,
1035    java.util.Collection JavaDoc values
1036  ) {
1037    refAddValue(
1038      "org:opencrx:kernel:contract1:AbstractContract:expiresOn",
1039      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1040      operator,
1041      values
1042    );
1043  }
1044
1045  public void forAllExpiresOn (
1046    short operator,
1047    java.util.Date JavaDoc[] filterValues
1048  ) {
1049    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1050    for(int i = 0; i < filterValues.length; i++) {
1051      arrayAsList.add(
1052        filterValues[i]
1053      );
1054    }
1055    forAllExpiresOn (
1056      operator,
1057      arrayAsList
1058    );
1059  }
1060
1061  public void thereExistsExpiresOn (
1062    short operator,
1063    java.util.Date JavaDoc[] filterValues
1064  ) {
1065    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1066    for(int i = 0; i < filterValues.length; i++) {
1067      arrayAsList.add(
1068        filterValues[i]
1069      );
1070    }
1071    thereExistsExpiresOn (
1072      operator,
1073      arrayAsList
1074    );
1075  }
1076
1077  public void orderByExpiresOn (
1078    short order
1079  ) {
1080    refAddValue(
1081      "org:opencrx:kernel:contract1:AbstractContract:expiresOn",
1082      order
1083    );
1084  }
1085      
1086// ----------------------------------------------------------------------------
1087
// Filter/ImplReference
1088
// ----------------------------------------------------------------------------
1089
public void forAllInventoryCb (
1090    short operator,
1091    org.opencrx.kernel.depot1.cci.CompoundBooking[] filterValues
1092  ) {
1093    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1094    for(int i = 0; i < filterValues.length; i++) {
1095      arrayAsList.add(
1096        filterValues[i]
1097      );
1098    }
1099    forAllInventoryCb (
1100      operator,
1101      arrayAsList
1102    );
1103  }
1104
1105  public void thereExistsInventoryCb (
1106    short operator,
1107    org.opencrx.kernel.depot1.cci.CompoundBooking[] filterValues
1108  ) {
1109    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1110    for(int i = 0; i < filterValues.length; i++) {
1111      arrayAsList.add(
1112        filterValues[i]
1113      );
1114    }
1115    thereExistsInventoryCb (
1116      operator,
1117      arrayAsList
1118    );
1119  }
1120
1121  public void forAllInventoryCb (
1122    short operator,
1123    java.util.Collection JavaDoc values
1124  ) {
1125    refAddValue(
1126      "org:opencrx:kernel:contract1:AbstractContract:inventoryCb",
1127      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1128      operator,
1129      values
1130    );
1131  }
1132
1133  public void thereExistsInventoryCb (
1134    short operator,
1135    java.util.Collection JavaDoc values
1136  ) {
1137    refAddValue(
1138      "org:opencrx:kernel:contract1:AbstractContract:inventoryCb",
1139      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1140      operator,
1141      values
1142    );
1143  }
1144      
1145// ----------------------------------------------------------------------------
1146
// Filter/ImplAttributeIsNotStruct
1147
// ----------------------------------------------------------------------------
1148
public void forAllName (
1149    short operator,
1150    java.util.Collection JavaDoc values
1151  ) {
1152    refAddValue(
1153      "org:opencrx:kernel:contract1:AbstractContract:name",
1154      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1155      operator,
1156      values
1157    );
1158  }
1159
1160  public void thereExistsName (
1161    short operator,
1162    java.util.Collection JavaDoc values
1163  ) {
1164    refAddValue(
1165      "org:opencrx:kernel:contract1:AbstractContract:name",
1166      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1167      operator,
1168      values
1169    );
1170  }
1171
1172  public void forAllName (
1173    short operator,
1174    String JavaDoc[] filterValues
1175  ) {
1176    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1177    for(int i = 0; i < filterValues.length; i++) {
1178      arrayAsList.add(
1179        filterValues[i]
1180      );
1181    }
1182    forAllName (
1183      operator,
1184      arrayAsList
1185    );
1186  }
1187
1188  public void thereExistsName (
1189    short operator,
1190    String JavaDoc[] filterValues
1191  ) {
1192    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1193    for(int i = 0; i < filterValues.length; i++) {
1194      arrayAsList.add(
1195        filterValues[i]
1196      );
1197    }
1198    thereExistsName (
1199      operator,
1200      arrayAsList
1201    );
1202  }
1203
1204  public void orderByName (
1205    short order
1206  ) {
1207    refAddValue(
1208      "org:opencrx:kernel:contract1:AbstractContract:name",
1209      order
1210    );
1211  }
1212      
1213// ----------------------------------------------------------------------------
1214
// Filter/ImplReference
1215
// ----------------------------------------------------------------------------
1216
public void forAllOrigin (
1217    short operator,
1218    org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
1219  ) {
1220    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1221    for(int i = 0; i < filterValues.length; i++) {
1222      arrayAsList.add(
1223        filterValues[i]
1224      );
1225    }
1226    forAllOrigin (
1227      operator,
1228      arrayAsList
1229    );
1230  }
1231
1232  public void thereExistsOrigin (
1233    short operator,
1234    org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
1235  ) {
1236    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1237    for(int i = 0; i < filterValues.length; i++) {
1238      arrayAsList.add(
1239        filterValues[i]
1240      );
1241    }
1242    thereExistsOrigin (
1243      operator,
1244      arrayAsList
1245    );
1246  }
1247
1248  public void forAllOrigin (
1249    short operator,
1250    java.util.Collection JavaDoc values
1251  ) {
1252    refAddValue(
1253      "org:opencrx:kernel:contract1:AbstractContract:origin",
1254      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1255      operator,
1256      values
1257    );
1258  }
1259
1260  public void thereExistsOrigin (
1261    short operator,
1262    java.util.Collection JavaDoc values
1263  ) {
1264    refAddValue(
1265      "org:opencrx:kernel:contract1:AbstractContract:origin",
1266      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1267      operator,
1268      values
1269    );
1270  }
1271      
1272// ----------------------------------------------------------------------------
1273
// Filter/ImplAttributeIsNotStruct
1274
// ----------------------------------------------------------------------------
1275
public void forAllPaymentTerms (
1276    short operator,
1277    java.util.Collection JavaDoc values
1278  ) {
1279    refAddValue(
1280      "org:opencrx:kernel:contract1:AbstractContract:paymentTerms",
1281      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1282      operator,
1283      values
1284    );
1285  }
1286
1287  public void thereExistsPaymentTerms (
1288    short operator,
1289    java.util.Collection JavaDoc values
1290  ) {
1291    refAddValue(
1292      "org:opencrx:kernel:contract1:AbstractContract:paymentTerms",
1293      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1294      operator,
1295      values
1296    );
1297  }
1298
1299  public void forAllPaymentTerms (
1300    short operator,
1301    short[] filterValues
1302  ) {
1303    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1304    for(int i = 0; i < filterValues.length; i++) {
1305      arrayAsList.add(
1306        new Short JavaDoc(filterValues[i])
1307      );
1308    }
1309    forAllPaymentTerms (
1310      operator,
1311      arrayAsList
1312    );
1313  }
1314
1315  public void thereExistsPaymentTerms (
1316    short operator,
1317    short[] filterValues
1318  ) {
1319    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1320    for(int i = 0; i < filterValues.length; i++) {
1321      arrayAsList.add(
1322        new Short JavaDoc(filterValues[i])
1323      );
1324    }
1325    thereExistsPaymentTerms (
1326      operator,
1327      arrayAsList
1328    );
1329  }
1330
1331  public void orderByPaymentTerms (
1332    short order
1333  ) {
1334    refAddValue(
1335      "org:opencrx:kernel:contract1:AbstractContract:paymentTerms",
1336      order
1337    );
1338  }
1339      
1340// ----------------------------------------------------------------------------
1341
// Filter/ImplAttributeIsNotStruct
1342
// ----------------------------------------------------------------------------
1343
public void forAllPricingDate (
1344    short operator,
1345    java.util.Collection JavaDoc values
1346  ) {
1347    refAddValue(
1348      "org:opencrx:kernel:contract1:AbstractContract:pricingDate",
1349      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1350      operator,
1351      values
1352    );
1353  }
1354
1355  public void thereExistsPricingDate (
1356    short operator,
1357    java.util.Collection JavaDoc values
1358  ) {
1359    refAddValue(
1360      "org:opencrx:kernel:contract1:AbstractContract:pricingDate",
1361      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1362      operator,
1363      values
1364    );
1365  }
1366
1367  public void forAllPricingDate (
1368    short operator,
1369    java.util.Date JavaDoc[] filterValues
1370  ) {
1371    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1372    for(int i = 0; i < filterValues.length; i++) {
1373      arrayAsList.add(
1374        filterValues[i]
1375      );
1376    }
1377    forAllPricingDate (
1378      operator,
1379      arrayAsList
1380    );
1381  }
1382
1383  public void thereExistsPricingDate (
1384    short operator,
1385    java.util.Date JavaDoc[] filterValues
1386  ) {
1387    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1388    for(int i = 0; i < filterValues.length; i++) {
1389      arrayAsList.add(
1390        filterValues[i]
1391      );
1392    }
1393    thereExistsPricingDate (
1394      operator,
1395      arrayAsList
1396    );
1397  }
1398
1399  public void orderByPricingDate (
1400    short order
1401  ) {
1402    refAddValue(
1403      "org:opencrx:kernel:contract1:AbstractContract:pricingDate",
1404      order
1405    );
1406  }
1407      
1408// ----------------------------------------------------------------------------
1409
// Filter/ImplReference
1410
// ----------------------------------------------------------------------------
1411
public void forAllPricingRule (
1412    short operator,
1413    org.opencrx.kernel.product1.cci.PricingRule[] filterValues
1414  ) {
1415    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1416    for(int i = 0; i < filterValues.length; i++) {
1417      arrayAsList.add(
1418        filterValues[i]
1419      );
1420    }
1421    forAllPricingRule (
1422      operator,
1423      arrayAsList
1424    );
1425  }
1426
1427  public void thereExistsPricingRule (
1428    short operator,
1429    org.opencrx.kernel.product1.cci.PricingRule[] filterValues
1430  ) {
1431    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1432    for(int i = 0; i < filterValues.length; i++) {
1433      arrayAsList.add(
1434        filterValues[i]
1435      );
1436    }
1437    thereExistsPricingRule (
1438      operator,
1439      arrayAsList
1440    );
1441  }
1442
1443  public void forAllPricingRule (
1444    short operator,
1445    java.util.Collection JavaDoc values
1446  ) {
1447    refAddValue(
1448      "org:opencrx:kernel:contract1:AbstractContract:pricingRule",
1449      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1450      operator,
1451      values
1452    );
1453  }
1454
1455  public void thereExistsPricingRule (
1456    short operator,
1457    java.util.Collection JavaDoc values
1458  ) {
1459    refAddValue(
1460      "org:opencrx:kernel:contract1:AbstractContract:pricingRule",
1461      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1462      operator,
1463      values
1464    );
1465  }
1466      
1467// ----------------------------------------------------------------------------
1468
// Filter/ImplAttributeIsNotStruct
1469
// ----------------------------------------------------------------------------
1470
public void forAllPricingState (
1471    short operator,
1472    java.util.Collection JavaDoc values
1473  ) {
1474    refAddValue(
1475      "org:opencrx:kernel:contract1:AbstractContract:pricingState",
1476      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1477      operator,
1478      values
1479    );
1480  }
1481
1482  public void thereExistsPricingState (
1483    short operator,
1484    java.util.Collection JavaDoc values
1485  ) {
1486    refAddValue(
1487      "org:opencrx:kernel:contract1:AbstractContract:pricingState",
1488      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1489      operator,
1490      values
1491    );
1492  }
1493
1494  public void forAllPricingState (
1495    short operator,
1496    short[] filterValues
1497  ) {
1498    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1499    for(int i = 0; i < filterValues.length; i++) {
1500      arrayAsList.add(
1501        new Short JavaDoc(filterValues[i])
1502      );
1503    }
1504    forAllPricingState (
1505      operator,
1506      arrayAsList
1507    );
1508  }
1509
1510  public void thereExistsPricingState (
1511    short operator,
1512    short[] filterValues
1513  ) {
1514    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1515    for(int i = 0; i < filterValues.length; i++) {
1516      arrayAsList.add(
1517        new Short JavaDoc(filterValues[i])
1518      );
1519    }
1520    thereExistsPricingState (
1521      operator,
1522      arrayAsList
1523    );
1524  }
1525
1526  public void orderByPricingState (
1527    short order
1528  ) {
1529    refAddValue(
1530      "org:opencrx:kernel:contract1:AbstractContract:pricingState",
1531      order
1532    );
1533  }
1534      
1535// ----------------------------------------------------------------------------
1536
// Filter/ImplAttributeIsNotStruct
1537
// ----------------------------------------------------------------------------
1538
public void forAllPriority (
1539    short operator,
1540    java.util.Collection JavaDoc values
1541  ) {
1542    refAddValue(
1543      "org:opencrx:kernel:contract1:AbstractContract:priority",
1544      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1545      operator,
1546      values
1547    );
1548  }
1549
1550  public void thereExistsPriority (
1551    short operator,
1552    java.util.Collection JavaDoc values
1553  ) {
1554    refAddValue(
1555      "org:opencrx:kernel:contract1:AbstractContract:priority",
1556      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1557      operator,
1558      values
1559    );
1560  }
1561
1562  public void forAllPriority (
1563    short operator,
1564    short[] filterValues
1565  ) {
1566    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1567    for(int i = 0; i < filterValues.length; i++) {
1568      arrayAsList.add(
1569        new Short JavaDoc(filterValues[i])
1570      );
1571    }
1572    forAllPriority (
1573      operator,
1574      arrayAsList
1575    );
1576  }
1577
1578  public void thereExistsPriority (
1579    short operator,
1580    short[] filterValues
1581  ) {
1582    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1583    for(int i = 0; i < filterValues.length; i++) {
1584      arrayAsList.add(
1585        new Short JavaDoc(filterValues[i])
1586      );
1587    }
1588    thereExistsPriority (
1589      operator,
1590      arrayAsList
1591    );
1592  }
1593
1594  public void orderByPriority (
1595    short order
1596  ) {
1597    refAddValue(
1598      "org:opencrx:kernel:contract1:AbstractContract:priority",
1599      order
1600    );
1601  }
1602      
1603// ----------------------------------------------------------------------------
1604
// Filter/ImplReference
1605
// ----------------------------------------------------------------------------
1606
public void forAllSalesRep (
1607    short operator,
1608    org.opencrx.kernel.account1.cci.Account[] filterValues
1609  ) {
1610    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1611    for(int i = 0; i < filterValues.length; i++) {
1612      arrayAsList.add(
1613        filterValues[i]
1614      );
1615    }
1616    forAllSalesRep (
1617      operator,
1618      arrayAsList
1619    );
1620  }
1621
1622  public void thereExistsSalesRep (
1623    short operator,
1624    org.opencrx.kernel.account1.cci.Account[] filterValues
1625  ) {
1626    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1627    for(int i = 0; i < filterValues.length; i++) {
1628      arrayAsList.add(
1629        filterValues[i]
1630      );
1631    }
1632    thereExistsSalesRep (
1633      operator,
1634      arrayAsList
1635    );
1636  }
1637
1638  public void forAllSalesRep (
1639    short operator,
1640    java.util.Collection JavaDoc values
1641  ) {
1642    refAddValue(
1643      "org:opencrx:kernel:contract1:AbstractContract:salesRep",
1644      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1645      operator,
1646      values
1647    );
1648  }
1649
1650  public void thereExistsSalesRep (
1651    short operator,
1652    java.util.Collection JavaDoc values
1653  ) {
1654    refAddValue(
1655      "org:opencrx:kernel:contract1:AbstractContract:salesRep",
1656      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1657      operator,
1658      values
1659    );
1660  }
1661      
1662// ----------------------------------------------------------------------------
1663
// Filter/ImplAttributeIsNotStruct
1664
// ----------------------------------------------------------------------------
1665
public void forAllTotalAmount (
1666    short operator,
1667    java.util.Collection JavaDoc values
1668  ) {
1669    refAddValue(
1670      "org:opencrx:kernel:contract1:AbstractContract:totalAmount",
1671      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1672      operator,
1673      values
1674    );
1675  }
1676
1677  public void thereExistsTotalAmount (
1678    short operator,
1679    java.util.Collection JavaDoc values
1680  ) {
1681    refAddValue(
1682      "org:opencrx:kernel:contract1:AbstractContract:totalAmount",
1683      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1684      operator,
1685      values
1686    );
1687  }
1688
1689  public void forAllTotalAmount (
1690    short operator,
1691    java.math.BigDecimal JavaDoc[] filterValues
1692  ) {
1693    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1694    for(int i = 0; i < filterValues.length; i++) {
1695      arrayAsList.add(
1696        filterValues[i]
1697      );
1698    }
1699    forAllTotalAmount (
1700      operator,
1701      arrayAsList
1702    );
1703  }
1704
1705  public void thereExistsTotalAmount (
1706    short operator,
1707    java.math.BigDecimal JavaDoc[] filterValues
1708  ) {
1709    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1710    for(int i = 0; i < filterValues.length; i++) {
1711      arrayAsList.add(
1712        filterValues[i]
1713      );
1714    }
1715    thereExistsTotalAmount (
1716      operator,
1717      arrayAsList
1718    );
1719  }
1720
1721  public void orderByTotalAmount (
1722    short order
1723  ) {
1724    refAddValue(
1725      "org:opencrx:kernel:contract1:AbstractContract:totalAmount",
1726      order
1727    );
1728  }
1729      
1730// ----------------------------------------------------------------------------
1731
// Filter/ImplAttributeIsNotStruct
1732
// ----------------------------------------------------------------------------
1733
public void forAllTotalAmountIncludingTax (
1734    short operator,
1735    java.util.Collection JavaDoc values
1736  ) {
1737    refAddValue(
1738      "org:opencrx:kernel:contract1:AbstractContract:totalAmountIncludingTax",
1739      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1740      operator,
1741      values
1742    );
1743  }
1744
1745  public void thereExistsTotalAmountIncludingTax (
1746    short operator,
1747    java.util.Collection JavaDoc values
1748  ) {
1749    refAddValue(
1750      "org:opencrx:kernel:contract1:AbstractContract:totalAmountIncludingTax",
1751      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1752      operator,
1753      values
1754    );
1755  }
1756
1757  public void forAllTotalAmountIncludingTax (
1758    short operator,
1759    java.math.BigDecimal JavaDoc[] filterValues
1760  ) {
1761    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1762    for(int i = 0; i < filterValues.length; i++) {
1763      arrayAsList.add(
1764        filterValues[i]
1765      );
1766    }
1767    forAllTotalAmountIncludingTax (
1768      operator,
1769      arrayAsList
1770    );
1771  }
1772
1773  public void thereExistsTotalAmountIncludingTax (
1774    short operator,
1775    java.math.BigDecimal JavaDoc[] filterValues
1776  ) {
1777    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1778    for(int i = 0; i < filterValues.length; i++) {
1779      arrayAsList.add(
1780        filterValues[i]
1781      );
1782    }
1783    thereExistsTotalAmountIncludingTax (
1784      operator,
1785      arrayAsList
1786    );
1787  }
1788
1789  public void orderByTotalAmountIncludingTax (
1790    short order
1791  ) {
1792    refAddValue(
1793      "org:opencrx:kernel:contract1:AbstractContract:totalAmountIncludingTax",
1794      order
1795    );
1796  }
1797      
1798// ----------------------------------------------------------------------------
1799
// Filter/ImplAttributeIsNotStruct
1800
// ----------------------------------------------------------------------------
1801
public void forAllTotalBaseAmount (
1802    short operator,
1803    java.util.Collection JavaDoc values
1804  ) {
1805    refAddValue(
1806      "org:opencrx:kernel:contract1:AbstractContract:totalBaseAmount",
1807      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1808      operator,
1809      values
1810    );
1811  }
1812
1813  public void thereExistsTotalBaseAmount (
1814    short operator,
1815    java.util.Collection JavaDoc values
1816  ) {
1817    refAddValue(
1818      "org:opencrx:kernel:contract1:AbstractContract:totalBaseAmount",
1819      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1820      operator,
1821      values
1822    );
1823  }
1824
1825  public void forAllTotalBaseAmount (
1826    short operator,
1827    java.math.BigDecimal JavaDoc[] filterValues
1828  ) {
1829    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1830    for(int i = 0; i < filterValues.length; i++) {
1831      arrayAsList.add(
1832        filterValues[i]
1833      );
1834    }
1835    forAllTotalBaseAmount (
1836      operator,
1837      arrayAsList
1838    );
1839  }
1840
1841  public void thereExistsTotalBaseAmount (
1842    short operator,
1843    java.math.BigDecimal JavaDoc[] filterValues
1844  ) {
1845    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1846    for(int i = 0; i < filterValues.length; i++) {
1847      arrayAsList.add(
1848        filterValues[i]
1849      );
1850    }
1851    thereExistsTotalBaseAmount (
1852      operator,
1853      arrayAsList
1854    );
1855  }
1856
1857  public void orderByTotalBaseAmount (
1858    short order
1859  ) {
1860    refAddValue(
1861      "org:opencrx:kernel:contract1:AbstractContract:totalBaseAmount",
1862      order
1863    );
1864  }
1865      
1866// ----------------------------------------------------------------------------
1867
// Filter/ImplAttributeIsNotStruct
1868
// ----------------------------------------------------------------------------
1869
public void forAllTotalDiscountAmount (
1870    short operator,
1871    java.util.Collection JavaDoc values
1872  ) {
1873    refAddValue(
1874      "org:opencrx:kernel:contract1:AbstractContract:totalDiscountAmount",
1875      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1876      operator,
1877      values
1878    );
1879  }
1880
1881  public void thereExistsTotalDiscountAmount (
1882    short operator,
1883    java.util.Collection JavaDoc values
1884  ) {
1885    refAddValue(
1886      "org:opencrx:kernel:contract1:AbstractContract:totalDiscountAmount",
1887      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1888      operator,
1889      values
1890    );
1891  }
1892
1893  public void forAllTotalDiscountAmount (
1894    short operator,
1895    java.math.BigDecimal JavaDoc[] filterValues
1896  ) {
1897    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1898    for(int i = 0; i < filterValues.length; i++) {
1899      arrayAsList.add(
1900        filterValues[i]
1901      );
1902    }
1903    forAllTotalDiscountAmount (
1904      operator,
1905      arrayAsList
1906    );
1907  }
1908
1909  public void thereExistsTotalDiscountAmount (
1910    short operator,
1911    java.math.BigDecimal JavaDoc[] filterValues
1912  ) {
1913    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1914    for(int i = 0; i < filterValues.length; i++) {
1915      arrayAsList.add(
1916        filterValues[i]
1917      );
1918    }
1919    thereExistsTotalDiscountAmount (
1920      operator,
1921      arrayAsList
1922    );
1923  }
1924
1925  public void orderByTotalDiscountAmount (
1926    short order
1927  ) {
1928    refAddValue(
1929      "org:opencrx:kernel:contract1:AbstractContract:totalDiscountAmount",
1930      order
1931    );
1932  }
1933      
1934// ----------------------------------------------------------------------------
1935
// Filter/ImplAttributeIsNotStruct
1936
// ----------------------------------------------------------------------------
1937
public void forAllTotalSalesCommission (
1938    short operator,
1939    java.util.Collection JavaDoc values
1940  ) {
1941    refAddValue(
1942      "org:opencrx:kernel:contract1:AbstractContract:totalSalesCommission",
1943      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1944      operator,
1945      values
1946    );
1947  }
1948
1949  public void thereExistsTotalSalesCommission (
1950    short operator,
1951    java.util.Collection JavaDoc values
1952  ) {
1953    refAddValue(
1954      "org:opencrx:kernel:contract1:AbstractContract:totalSalesCommission",
1955      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1956      operator,
1957      values
1958    );
1959  }
1960
1961  public void forAllTotalSalesCommission (
1962    short operator,
1963    java.math.BigDecimal JavaDoc[] filterValues
1964  ) {
1965    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1966    for(int i = 0; i < filterValues.length; i++) {
1967      arrayAsList.add(
1968        filterValues[i]
1969      );
1970    }
1971    forAllTotalSalesCommission (
1972      operator,
1973      arrayAsList
1974    );
1975  }
1976
1977  public void thereExistsTotalSalesCommission (
1978    short operator,
1979    java.math.BigDecimal JavaDoc[] filterValues
1980  ) {
1981    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
1982    for(int i = 0; i < filterValues.length; i++) {
1983      arrayAsList.add(
1984        filterValues[i]
1985      );
1986    }
1987    thereExistsTotalSalesCommission (
1988      operator,
1989      arrayAsList
1990    );
1991  }
1992
1993  public void orderByTotalSalesCommission (
1994    short order
1995  ) {
1996    refAddValue(
1997      "org:opencrx:kernel:contract1:AbstractContract:totalSalesCommission",
1998      order
1999    );
2000  }
2001      
2002// ----------------------------------------------------------------------------
2003
// Filter/ImplAttributeIsNotStruct
2004
// ----------------------------------------------------------------------------
2005
public void forAllTotalTaxAmount (
2006    short operator,
2007    java.util.Collection JavaDoc values
2008  ) {
2009    refAddValue(
2010      "org:opencrx:kernel:contract1:AbstractContract:totalTaxAmount",
2011      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2012      operator,
2013      values
2014    );
2015  }
2016
2017  public void thereExistsTotalTaxAmount (
2018    short operator,
2019    java.util.Collection JavaDoc values
2020  ) {
2021    refAddValue(
2022      "org:opencrx:kernel:contract1:AbstractContract:totalTaxAmount",
2023      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2024      operator,
2025      values
2026    );
2027  }
2028
2029  public void forAllTotalTaxAmount (
2030    short operator,
2031    java.math.BigDecimal JavaDoc[] filterValues
2032  ) {
2033    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2034    for(int i = 0; i < filterValues.length; i++) {
2035      arrayAsList.add(
2036        filterValues[i]
2037      );
2038    }
2039    forAllTotalTaxAmount (
2040      operator,
2041      arrayAsList
2042    );
2043  }
2044
2045  public void thereExistsTotalTaxAmount (
2046    short operator,
2047    java.math.BigDecimal JavaDoc[] filterValues
2048  ) {
2049    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2050    for(int i = 0; i < filterValues.length; i++) {
2051      arrayAsList.add(
2052        filterValues[i]
2053      );
2054    }
2055    thereExistsTotalTaxAmount (
2056      operator,
2057      arrayAsList
2058    );
2059  }
2060
2061  public void orderByTotalTaxAmount (
2062    short order
2063  ) {
2064    refAddValue(
2065      "org:opencrx:kernel:contract1:AbstractContract:totalTaxAmount",
2066      order
2067    );
2068  }
2069      
2070// ----------------------------------------------------------------------------
2071
// Filter/ImplReference
2072
// ----------------------------------------------------------------------------
2073
public void forAllCarrier (
2074    short operator,
2075    org.opencrx.kernel.account1.cci.Account[] filterValues
2076  ) {
2077    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2078    for(int i = 0; i < filterValues.length; i++) {
2079      arrayAsList.add(
2080        filterValues[i]
2081      );
2082    }
2083    forAllCarrier (
2084      operator,
2085      arrayAsList
2086    );
2087  }
2088
2089  public void thereExistsCarrier (
2090    short operator,
2091    org.opencrx.kernel.account1.cci.Account[] filterValues
2092  ) {
2093    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2094    for(int i = 0; i < filterValues.length; i++) {
2095      arrayAsList.add(
2096        filterValues[i]
2097      );
2098    }
2099    thereExistsCarrier (
2100      operator,
2101      arrayAsList
2102    );
2103  }
2104
2105  public void forAllCarrier (
2106    short operator,
2107    java.util.Collection JavaDoc values
2108  ) {
2109    refAddValue(
2110      "org:opencrx:kernel:contract1:ShippingDetail:carrier",
2111      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2112      operator,
2113      values
2114    );
2115  }
2116
2117  public void thereExistsCarrier (
2118    short operator,
2119    java.util.Collection JavaDoc values
2120  ) {
2121    refAddValue(
2122      "org:opencrx:kernel:contract1:ShippingDetail:carrier",
2123      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2124      operator,
2125      values
2126    );
2127  }
2128      
2129// ----------------------------------------------------------------------------
2130
// Filter/ImplAttributeIsNotStruct
2131
// ----------------------------------------------------------------------------
2132
public void forAllGiftMessage (
2133    short operator,
2134    java.util.Collection JavaDoc values
2135  ) {
2136    refAddValue(
2137      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2138      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2139      operator,
2140      values
2141    );
2142  }
2143
2144  public void thereExistsGiftMessage (
2145    short operator,
2146    java.util.Collection JavaDoc values
2147  ) {
2148    refAddValue(
2149      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2150      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2151      operator,
2152      values
2153    );
2154  }
2155
2156  public void forAllGiftMessage (
2157    short operator,
2158    String JavaDoc[] filterValues
2159  ) {
2160    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2161    for(int i = 0; i < filterValues.length; i++) {
2162      arrayAsList.add(
2163        filterValues[i]
2164      );
2165    }
2166    forAllGiftMessage (
2167      operator,
2168      arrayAsList
2169    );
2170  }
2171
2172  public void thereExistsGiftMessage (
2173    short operator,
2174    String JavaDoc[] filterValues
2175  ) {
2176    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2177    for(int i = 0; i < filterValues.length; i++) {
2178      arrayAsList.add(
2179        filterValues[i]
2180      );
2181    }
2182    thereExistsGiftMessage (
2183      operator,
2184      arrayAsList
2185    );
2186  }
2187
2188  public void orderByGiftMessage (
2189    short order
2190  ) {
2191    refAddValue(
2192      "org:opencrx:kernel:contract1:ShippingDetail:giftMessage",
2193      order
2194    );
2195  }
2196      
2197// ----------------------------------------------------------------------------
2198
// Filter/ImplAttributeIsNotStruct
2199
// ----------------------------------------------------------------------------
2200
public void forAllIsGift (
2201    short operator,
2202    java.util.Collection JavaDoc values
2203  ) {
2204    refAddValue(
2205      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2206      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2207      operator,
2208      values
2209    );
2210  }
2211
2212  public void thereExistsIsGift (
2213    short operator,
2214    java.util.Collection JavaDoc values
2215  ) {
2216    refAddValue(
2217      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2218      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2219      operator,
2220      values
2221    );
2222  }
2223
2224  public void forAllIsGift (
2225    short operator,
2226    boolean[] filterValues
2227  ) {
2228    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2229    for(int i = 0; i < filterValues.length; i++) {
2230      arrayAsList.add(
2231        new Boolean JavaDoc(filterValues[i])
2232      );
2233    }
2234    forAllIsGift (
2235      operator,
2236      arrayAsList
2237    );
2238  }
2239
2240  public void thereExistsIsGift (
2241    short operator,
2242    boolean[] filterValues
2243  ) {
2244    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2245    for(int i = 0; i < filterValues.length; i++) {
2246      arrayAsList.add(
2247        new Boolean JavaDoc(filterValues[i])
2248      );
2249    }
2250    thereExistsIsGift (
2251      operator,
2252      arrayAsList
2253    );
2254  }
2255
2256  public void orderByIsGift (
2257    short order
2258  ) {
2259    refAddValue(
2260      "org:opencrx:kernel:contract1:ShippingDetail:isGift",
2261      order
2262    );
2263  }
2264      
2265// ----------------------------------------------------------------------------
2266
// Filter/ImplAttributeIsNotStruct
2267
// ----------------------------------------------------------------------------
2268
public void forAllShippingInstructions (
2269    short operator,
2270    java.util.Collection JavaDoc values
2271  ) {
2272    refAddValue(
2273      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2274      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2275      operator,
2276      values
2277    );
2278  }
2279
2280  public void thereExistsShippingInstructions (
2281    short operator,
2282    java.util.Collection JavaDoc values
2283  ) {
2284    refAddValue(
2285      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2286      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2287      operator,
2288      values
2289    );
2290  }
2291
2292  public void forAllShippingInstructions (
2293    short operator,
2294    String JavaDoc[] filterValues
2295  ) {
2296    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2297    for(int i = 0; i < filterValues.length; i++) {
2298      arrayAsList.add(
2299        filterValues[i]
2300      );
2301    }
2302    forAllShippingInstructions (
2303      operator,
2304      arrayAsList
2305    );
2306  }
2307
2308  public void thereExistsShippingInstructions (
2309    short operator,
2310    String JavaDoc[] filterValues
2311  ) {
2312    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2313    for(int i = 0; i < filterValues.length; i++) {
2314      arrayAsList.add(
2315        filterValues[i]
2316      );
2317    }
2318    thereExistsShippingInstructions (
2319      operator,
2320      arrayAsList
2321    );
2322  }
2323
2324  public void orderByShippingInstructions (
2325    short order
2326  ) {
2327    refAddValue(
2328      "org:opencrx:kernel:contract1:ShippingDetail:shippingInstructions",
2329      order
2330    );
2331  }
2332      
2333// ----------------------------------------------------------------------------
2334
// Filter/ImplAttributeIsNotStruct
2335
// ----------------------------------------------------------------------------
2336
public void forAllShippingMethod (
2337    short operator,
2338    java.util.Collection JavaDoc values
2339  ) {
2340    refAddValue(
2341      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2342      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2343      operator,
2344      values
2345    );
2346  }
2347
2348  public void thereExistsShippingMethod (
2349    short operator,
2350    java.util.Collection JavaDoc values
2351  ) {
2352    refAddValue(
2353      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2354      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2355      operator,
2356      values
2357    );
2358  }
2359
2360  public void forAllShippingMethod (
2361    short operator,
2362    short[] filterValues
2363  ) {
2364    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2365    for(int i = 0; i < filterValues.length; i++) {
2366      arrayAsList.add(
2367        new Short JavaDoc(filterValues[i])
2368      );
2369    }
2370    forAllShippingMethod (
2371      operator,
2372      arrayAsList
2373    );
2374  }
2375
2376  public void thereExistsShippingMethod (
2377    short operator,
2378    short[] filterValues
2379  ) {
2380    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2381    for(int i = 0; i < filterValues.length; i++) {
2382      arrayAsList.add(
2383        new Short JavaDoc(filterValues[i])
2384      );
2385    }
2386    thereExistsShippingMethod (
2387      operator,
2388      arrayAsList
2389    );
2390  }
2391
2392  public void orderByShippingMethod (
2393    short order
2394  ) {
2395    refAddValue(
2396      "org:opencrx:kernel:contract1:ShippingDetail:shippingMethod",
2397      order
2398    );
2399  }
2400      
2401// ----------------------------------------------------------------------------
2402
// Filter/ImplAttributeIsNotStruct
2403
// ----------------------------------------------------------------------------
2404
public void forAllShippingTrackingNumber (
2405    short operator,
2406    java.util.Collection JavaDoc values
2407  ) {
2408    refAddValue(
2409      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
2410      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2411      operator,
2412      values
2413    );
2414  }
2415
2416  public void thereExistsShippingTrackingNumber (
2417    short operator,
2418    java.util.Collection JavaDoc values
2419  ) {
2420    refAddValue(
2421      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
2422      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2423      operator,
2424      values
2425    );
2426  }
2427
2428  public void forAllShippingTrackingNumber (
2429    short operator,
2430    String JavaDoc[] filterValues
2431  ) {
2432    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2433    for(int i = 0; i < filterValues.length; i++) {
2434      arrayAsList.add(
2435        filterValues[i]
2436      );
2437    }
2438    forAllShippingTrackingNumber (
2439      operator,
2440      arrayAsList
2441    );
2442  }
2443
2444  public void thereExistsShippingTrackingNumber (
2445    short operator,
2446    String JavaDoc[] filterValues
2447  ) {
2448    java.util.List JavaDoc arrayAsList = new java.util.ArrayList JavaDoc();
2449    for(int i = 0; i < filterValues.length; i++) {
2450      arrayAsList.add(
2451        filterValues[i]
2452      );
2453    }
2454    thereExistsShippingTrackingNumber (
2455      operator,
2456      arrayAsList
2457    );
2458  }
2459
2460  public void orderByShippingTrackingNumber (
2461    short order
2462  ) {
2463    refAddValue(
2464      "org:opencrx:kernel:contract1:ShippingDetail:shippingTrackingNumber",
2465      order
2466    );
2467  }
2468      
2469// ----------------------------------------------------------------------------
2470
// Filter/ImplEnd
2471
// ----------------------------------------------------------------------------
2472
}
2473
Popular Tags