KickJava   Java API By Example, From Geeks To Geeks.

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


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