KickJava   Java API By Example, From Geeks To Geeks.

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


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