WarehouseFilterImpl


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:56 CEST 2006
9   //
10  // GENERATED - DO NOT CHANGE MANUALLY
11  //
12  //////////////////////////////////////////////////////////////////////////////
13  package org.opencrx.kernel.depot1.cci;
14  
15  public class WarehouseFilterImpl
16    extends org.openmdx.base.accessor.jmi.spi.RefFilter_1
17    implements WarehouseFilter {
18  
19    public WarehouseFilterImpl(
20      org.openmdx.base.accessor.jmi.cci.RefPackage_1_0 aPackage
21    ) {
22      super(
23        aPackage,
24        "org:opencrx:kernel:depot1:Warehouse",
25        null,
26        null
27      );
28    }
29  
30    public WarehouseFilterImpl(
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:depot1:Warehouse",
38        filterProperties,
39        attributeSpecifiers
40      );
41    }
42        
43  // ----------------------------------------------------------------------------
44  // Filter/ImplAttributeIsNotStruct
45  // ----------------------------------------------------------------------------
46    public void forAllAccessLevelBrowse (
47      short operator,
48      java.util.Collection   values
49    ) {
50      refAddValue(
51        "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
52        org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
53        operator,
54        values
55      );
56    }
57  
58    public void thereExistsAccessLevelBrowse (
59      short operator,
60      java.util.Collection   values
61    ) {
62      refAddValue(
63        "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
64        org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
65        operator,
66        values
67      );
68    }
69  
70    public void forAllAccessLevelBrowse (
71      short operator,
72      short[] filterValues
73    ) {
74      java.util.List   arrayAsList = new java.util.ArrayList  ();
75      for(int i = 0; i < filterValues.length; i++) {
76        arrayAsList.add(
77          new Short  (filterValues[i])
78        );
79      }
80      forAllAccessLevelBrowse (
81        operator,
82        arrayAsList
83      );
84    }
85  
86    public void thereExistsAccessLevelBrowse (
87      short operator,
88      short[] filterValues
89    ) {
90      java.util.List   arrayAsList = new java.util.ArrayList  ();
91      for(int i = 0; i < filterValues.length; i++) {
92        arrayAsList.add(
93          new Short  (filterValues[i])
94        );
95      }
96      thereExistsAccessLevelBrowse (
97        operator,
98        arrayAsList
99      );
100   }
101 
102   public void orderByAccessLevelBrowse (
103     short order
104   ) {
105     refAddValue(
106       "org:opencrx:kernel:base:SecureObject:accessLevelBrowse",
107       order
108     );
109   }
110       
111 // ----------------------------------------------------------------------------
112 // Filter/ImplAttributeIsNotStruct
113 // ----------------------------------------------------------------------------
114   public void forAllAccessLevelDelete (
115     short operator,
116     java.util.Collection   values
117   ) {
118     refAddValue(
119       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
120       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
121       operator,
122       values
123     );
124   }
125 
126   public void thereExistsAccessLevelDelete (
127     short operator,
128     java.util.Collection   values
129   ) {
130     refAddValue(
131       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
132       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
133       operator,
134       values
135     );
136   }
137 
138   public void forAllAccessLevelDelete (
139     short operator,
140     short[] filterValues
141   ) {
142     java.util.List   arrayAsList = new java.util.ArrayList  ();
143     for(int i = 0; i < filterValues.length; i++) {
144       arrayAsList.add(
145         new Short  (filterValues[i])
146       );
147     }
148     forAllAccessLevelDelete (
149       operator,
150       arrayAsList
151     );
152   }
153 
154   public void thereExistsAccessLevelDelete (
155     short operator,
156     short[] filterValues
157   ) {
158     java.util.List   arrayAsList = new java.util.ArrayList  ();
159     for(int i = 0; i < filterValues.length; i++) {
160       arrayAsList.add(
161         new Short  (filterValues[i])
162       );
163     }
164     thereExistsAccessLevelDelete (
165       operator,
166       arrayAsList
167     );
168   }
169 
170   public void orderByAccessLevelDelete (
171     short order
172   ) {
173     refAddValue(
174       "org:opencrx:kernel:base:SecureObject:accessLevelDelete",
175       order
176     );
177   }
178       
179 // ----------------------------------------------------------------------------
180 // Filter/ImplAttributeIsNotStruct
181 // ----------------------------------------------------------------------------
182   public void forAllAccessLevelUpdate (
183     short operator,
184     java.util.Collection   values
185   ) {
186     refAddValue(
187       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
188       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
189       operator,
190       values
191     );
192   }
193 
194   public void thereExistsAccessLevelUpdate (
195     short operator,
196     java.util.Collection   values
197   ) {
198     refAddValue(
199       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
200       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
201       operator,
202       values
203     );
204   }
205 
206   public void forAllAccessLevelUpdate (
207     short operator,
208     short[] filterValues
209   ) {
210     java.util.List   arrayAsList = new java.util.ArrayList  ();
211     for(int i = 0; i < filterValues.length; i++) {
212       arrayAsList.add(
213         new Short  (filterValues[i])
214       );
215     }
216     forAllAccessLevelUpdate (
217       operator,
218       arrayAsList
219     );
220   }
221 
222   public void thereExistsAccessLevelUpdate (
223     short operator,
224     short[] filterValues
225   ) {
226     java.util.List   arrayAsList = new java.util.ArrayList  ();
227     for(int i = 0; i < filterValues.length; i++) {
228       arrayAsList.add(
229         new Short  (filterValues[i])
230       );
231     }
232     thereExistsAccessLevelUpdate (
233       operator,
234       arrayAsList
235     );
236   }
237 
238   public void orderByAccessLevelUpdate (
239     short order
240   ) {
241     refAddValue(
242       "org:opencrx:kernel:base:SecureObject:accessLevelUpdate",
243       order
244     );
245   }
246       
247 // ----------------------------------------------------------------------------
248 // Filter/ImplAttributeIsNotStruct
249 // ----------------------------------------------------------------------------
250   public void forAllOwner (
251     short operator,
252     java.util.Collection   values
253   ) {
254     refAddValue(
255       "org:opencrx:kernel:base:SecureObject:owner",
256       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
257       operator,
258       values
259     );
260   }
261 
262   public void thereExistsOwner (
263     short operator,
264     java.util.Collection   values
265   ) {
266     refAddValue(
267       "org:opencrx:kernel:base:SecureObject:owner",
268       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
269       operator,
270       values
271     );
272   }
273 
274   public void forAllOwner (
275     short operator,
276     String  [] filterValues
277   ) {
278     java.util.List   arrayAsList = new java.util.ArrayList  ();
279     for(int i = 0; i < filterValues.length; i++) {
280       arrayAsList.add(
281         filterValues[i]
282       );
283     }
284     forAllOwner (
285       operator,
286       arrayAsList
287     );
288   }
289 
290   public void thereExistsOwner (
291     short operator,
292     String  [] filterValues
293   ) {
294     java.util.List   arrayAsList = new java.util.ArrayList  ();
295     for(int i = 0; i < filterValues.length; i++) {
296       arrayAsList.add(
297         filterValues[i]
298       );
299     }
300     thereExistsOwner (
301       operator,
302       arrayAsList
303     );
304   }
305 
306   public void orderByOwner (
307     short order
308   ) {
309     refAddValue(
310       "org:opencrx:kernel:base:SecureObject:owner",
311       order
312     );
313   }
314       
315 // ----------------------------------------------------------------------------
316 // Filter/ImplReference
317 // ----------------------------------------------------------------------------
318   public void forAllOwningGroup (
319     short operator,
320     org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
321   ) {
322     java.util.List   arrayAsList = new java.util.ArrayList  ();
323     for(int i = 0; i < filterValues.length; i++) {
324       arrayAsList.add(
325         filterValues[i]
326       );
327     }
328     forAllOwningGroup (
329       operator,
330       arrayAsList
331     );
332   }
333 
334   public void thereExistsOwningGroup (
335     short operator,
336     org.opencrx.security.realm1.cci.PrincipalGroup[] filterValues
337   ) {
338     java.util.List   arrayAsList = new java.util.ArrayList  ();
339     for(int i = 0; i < filterValues.length; i++) {
340       arrayAsList.add(
341         filterValues[i]
342       );
343     }
344     thereExistsOwningGroup (
345       operator,
346       arrayAsList
347     );
348   }
349 
350   public void forAllOwningGroup (
351     short operator,
352     java.util.Collection   values
353   ) {
354     refAddValue(
355       "org:opencrx:kernel:base:SecureObject:owningGroup",
356       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
357       operator,
358       values
359     );
360   }
361 
362   public void thereExistsOwningGroup (
363     short operator,
364     java.util.Collection   values
365   ) {
366     refAddValue(
367       "org:opencrx:kernel:base:SecureObject:owningGroup",
368       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
369       operator,
370       values
371     );
372   }
373       
374 // ----------------------------------------------------------------------------
375 // Filter/ImplReference
376 // ----------------------------------------------------------------------------
377   public void forAllOwningUser (
378     short operator,
379     org.opencrx.security.realm1.cci.User[] filterValues
380   ) {
381     java.util.List   arrayAsList = new java.util.ArrayList  ();
382     for(int i = 0; i < filterValues.length; i++) {
383       arrayAsList.add(
384         filterValues[i]
385       );
386     }
387     forAllOwningUser (
388       operator,
389       arrayAsList
390     );
391   }
392 
393   public void thereExistsOwningUser (
394     short operator,
395     org.opencrx.security.realm1.cci.User[] filterValues
396   ) {
397     java.util.List   arrayAsList = new java.util.ArrayList  ();
398     for(int i = 0; i < filterValues.length; i++) {
399       arrayAsList.add(
400         filterValues[i]
401       );
402     }
403     thereExistsOwningUser (
404       operator,
405       arrayAsList
406     );
407   }
408 
409   public void forAllOwningUser (
410     short operator,
411     java.util.Collection   values
412   ) {
413     refAddValue(
414       "org:opencrx:kernel:base:SecureObject:owningUser",
415       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
416       operator,
417       values
418     );
419   }
420 
421   public void thereExistsOwningUser (
422     short operator,
423     java.util.Collection   values
424   ) {
425     refAddValue(
426       "org:opencrx:kernel:base:SecureObject:owningUser",
427       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
428       operator,
429       values
430     );
431   }
432       
433 // ----------------------------------------------------------------------------
434 // Filter/ImplAttributeIsNotStruct
435 // ----------------------------------------------------------------------------
436   public void forAllIsTemplate (
437     short operator,
438     java.util.Collection   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   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   arrayAsList = new java.util.ArrayList  ();
465     for(int i = 0; i < filterValues.length; i++) {
466       arrayAsList.add(
467         new Boolean  (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   arrayAsList = new java.util.ArrayList  ();
481     for(int i = 0; i < filterValues.length; i++) {
482       arrayAsList.add(
483         new Boolean  (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   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   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  [] filterValues
531   ) {
532     java.util.List   arrayAsList = new java.util.ArrayList  ();
533     for(int i = 0; i < filterValues.length; i++) {
534       arrayAsList.add(
535         filterValues[i]
536       );
537     }
538     forAllTemplateReferenceFilter (
539       operator,
540       arrayAsList
541     );
542   }
543 
544   public void thereExistsTemplateReferenceFilter (
545     short operator,
546     String  [] filterValues
547   ) {
548     java.util.List   arrayAsList = new java.util.ArrayList  ();
549     for(int i = 0; i < filterValues.length; i++) {
550       arrayAsList.add(
551         filterValues[i]
552       );
553     }
554     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/ImplReference
571 // ----------------------------------------------------------------------------
572   public void forAllContract (
573     short operator,
574     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
575   ) {
576     java.util.List   arrayAsList = new java.util.ArrayList  ();
577     for(int i = 0; i < filterValues.length; i++) {
578       arrayAsList.add(
579         filterValues[i]
580       );
581     }
582     forAllContract (
583       operator,
584       arrayAsList
585     );
586   }
587 
588   public void thereExistsContract (
589     short operator,
590     org.opencrx.kernel.contract1.cci.AbstractContract[] filterValues
591   ) {
592     java.util.List   arrayAsList = new java.util.ArrayList  ();
593     for(int i = 0; i < filterValues.length; i++) {
594       arrayAsList.add(
595         filterValues[i]
596       );
597     }
598     thereExistsContract (
599       operator,
600       arrayAsList
601     );
602   }
603 
604   public void forAllContract (
605     short operator,
606     java.util.Collection   values
607   ) {
608     refAddValue(
609       "org:opencrx:kernel:contract1:ContractReferenceHolder:contract",
610       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
611       operator,
612       values
613     );
614   }
615 
616   public void thereExistsContract (
617     short operator,
618     java.util.Collection   values
619   ) {
620     refAddValue(
621       "org:opencrx:kernel:contract1:ContractReferenceHolder:contract",
622       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
623       operator,
624       values
625     );
626   }
627       
628 // ----------------------------------------------------------------------------
629 // Filter/ImplAttributeIsNotStruct
630 // ----------------------------------------------------------------------------
631   public void forAllDepotHolderNumber (
632     short operator,
633     java.util.Collection   values
634   ) {
635     refAddValue(
636       "org:opencrx:kernel:depot1:DepotHolder:depotHolderNumber",
637       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
638       operator,
639       values
640     );
641   }
642 
643   public void thereExistsDepotHolderNumber (
644     short operator,
645     java.util.Collection   values
646   ) {
647     refAddValue(
648       "org:opencrx:kernel:depot1:DepotHolder:depotHolderNumber",
649       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
650       operator,
651       values
652     );
653   }
654 
655   public void forAllDepotHolderNumber (
656     short operator,
657     String  [] filterValues
658   ) {
659     java.util.List   arrayAsList = new java.util.ArrayList  ();
660     for(int i = 0; i < filterValues.length; i++) {
661       arrayAsList.add(
662         filterValues[i]
663       );
664     }
665     forAllDepotHolderNumber (
666       operator,
667       arrayAsList
668     );
669   }
670 
671   public void thereExistsDepotHolderNumber (
672     short operator,
673     String  [] filterValues
674   ) {
675     java.util.List   arrayAsList = new java.util.ArrayList  ();
676     for(int i = 0; i < filterValues.length; i++) {
677       arrayAsList.add(
678         filterValues[i]
679       );
680     }
681     thereExistsDepotHolderNumber (
682       operator,
683       arrayAsList
684     );
685   }
686 
687   public void orderByDepotHolderNumber (
688     short order
689   ) {
690     refAddValue(
691       "org:opencrx:kernel:depot1:DepotHolder:depotHolderNumber",
692       order
693     );
694   }
695       
696 // ----------------------------------------------------------------------------
697 // Filter/ImplAttributeIsNotStruct
698 // ----------------------------------------------------------------------------
699   public void forAllDescription (
700     short operator,
701     java.util.Collection   values
702   ) {
703     refAddValue(
704       "org:opencrx:kernel:depot1:DepotHolder:description",
705       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
706       operator,
707       values
708     );
709   }
710 
711   public void thereExistsDescription (
712     short operator,
713     java.util.Collection   values
714   ) {
715     refAddValue(
716       "org:opencrx:kernel:depot1:DepotHolder:description",
717       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
718       operator,
719       values
720     );
721   }
722 
723   public void forAllDescription (
724     short operator,
725     String  [] filterValues
726   ) {
727     java.util.List   arrayAsList = new java.util.ArrayList  ();
728     for(int i = 0; i < filterValues.length; i++) {
729       arrayAsList.add(
730         filterValues[i]
731       );
732     }
733     forAllDescription (
734       operator,
735       arrayAsList
736     );
737   }
738 
739   public void thereExistsDescription (
740     short operator,
741     String  [] filterValues
742   ) {
743     java.util.List   arrayAsList = new java.util.ArrayList  ();
744     for(int i = 0; i < filterValues.length; i++) {
745       arrayAsList.add(
746         filterValues[i]
747       );
748     }
749     thereExistsDescription (
750       operator,
751       arrayAsList
752     );
753   }
754 
755   public void orderByDescription (
756     short order
757   ) {
758     refAddValue(
759       "org:opencrx:kernel:depot1:DepotHolder:description",
760       order
761     );
762   }
763       
764 // ----------------------------------------------------------------------------
765 // Filter/ImplAttributeIsNotStruct
766 // ----------------------------------------------------------------------------
767   public void forAllName (
768     short operator,
769     java.util.Collection   values
770   ) {
771     refAddValue(
772       "org:opencrx:kernel:depot1:DepotHolder:name",
773       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
774       operator,
775       values
776     );
777   }
778 
779   public void thereExistsName (
780     short operator,
781     java.util.Collection   values
782   ) {
783     refAddValue(
784       "org:opencrx:kernel:depot1:DepotHolder:name",
785       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
786       operator,
787       values
788     );
789   }
790 
791   public void forAllName (
792     short operator,
793     String  [] filterValues
794   ) {
795     java.util.List   arrayAsList = new java.util.ArrayList  ();
796     for(int i = 0; i < filterValues.length; i++) {
797       arrayAsList.add(
798         filterValues[i]
799       );
800     }
801     forAllName (
802       operator,
803       arrayAsList
804     );
805   }
806 
807   public void thereExistsName (
808     short operator,
809     String  [] filterValues
810   ) {
811     java.util.List   arrayAsList = new java.util.ArrayList  ();
812     for(int i = 0; i < filterValues.length; i++) {
813       arrayAsList.add(
814         filterValues[i]
815       );
816     }
817     thereExistsName (
818       operator,
819       arrayAsList
820     );
821   }
822 
823   public void orderByName (
824     short order
825   ) {
826     refAddValue(
827       "org:opencrx:kernel:depot1:DepotHolder:name",
828       order
829     );
830   }
831       
832 // ----------------------------------------------------------------------------
833 // Filter/ImplAttributeIsNotStruct
834 // ----------------------------------------------------------------------------
835   public void forAllCategory (
836     short operator,
837     java.util.Collection   values
838   ) {
839     refAddValue(
840       "org:opencrx:kernel:generic:CrxObject:category",
841       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
842       operator,
843       values
844     );
845   }
846 
847   public void thereExistsCategory (
848     short operator,
849     java.util.Collection   values
850   ) {
851     refAddValue(
852       "org:opencrx:kernel:generic:CrxObject:category",
853       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
854       operator,
855       values
856     );
857   }
858 
859   public void forAllCategory (
860     short operator,
861     String  [] filterValues
862   ) {
863     java.util.List   arrayAsList = new java.util.ArrayList  ();
864     for(int i = 0; i < filterValues.length; i++) {
865       arrayAsList.add(
866         filterValues[i]
867       );
868     }
869     forAllCategory (
870       operator,
871       arrayAsList
872     );
873   }
874 
875   public void thereExistsCategory (
876     short operator,
877     String  [] filterValues
878   ) {
879     java.util.List   arrayAsList = new java.util.ArrayList  ();
880     for(int i = 0; i < filterValues.length; i++) {
881       arrayAsList.add(
882         filterValues[i]
883       );
884     }
885     thereExistsCategory (
886       operator,
887       arrayAsList
888     );
889   }
890 
891   public void orderByCategory (
892     short order
893   ) {
894     refAddValue(
895       "org:opencrx:kernel:generic:CrxObject:category",
896       order
897     );
898   }
899       
900 // ----------------------------------------------------------------------------
901 // Filter/ImplAttributeIsNotStruct
902 // ----------------------------------------------------------------------------
903   public void forAllDisabled (
904     short operator,
905     java.util.Collection   values
906   ) {
907     refAddValue(
908       "org:opencrx:kernel:generic:CrxObject:disabled",
909       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
910       operator,
911       values
912     );
913   }
914 
915   public void thereExistsDisabled (
916     short operator,
917     java.util.Collection   values
918   ) {
919     refAddValue(
920       "org:opencrx:kernel:generic:CrxObject:disabled",
921       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
922       operator,
923       values
924     );
925   }
926 
927   public void forAllDisabled (
928     short operator,
929     boolean[] filterValues
930   ) {
931     java.util.List   arrayAsList = new java.util.ArrayList  ();
932     for(int i = 0; i < filterValues.length; i++) {
933       arrayAsList.add(
934         new Boolean  (filterValues[i])
935       );
936     }
937     forAllDisabled (
938       operator,
939       arrayAsList
940     );
941   }
942 
943   public void thereExistsDisabled (
944     short operator,
945     boolean[] filterValues
946   ) {
947     java.util.List   arrayAsList = new java.util.ArrayList  ();
948     for(int i = 0; i < filterValues.length; i++) {
949       arrayAsList.add(
950         new Boolean  (filterValues[i])
951       );
952     }
953     thereExistsDisabled (
954       operator,
955       arrayAsList
956     );
957   }
958 
959   public void orderByDisabled (
960     short order
961   ) {
962     refAddValue(
963       "org:opencrx:kernel:generic:CrxObject:disabled",
964       order
965     );
966   }
967       
968 // ----------------------------------------------------------------------------
969 // Filter/ImplAttributeIsNotStruct
970 // ----------------------------------------------------------------------------
971   public void forAllDisabledReason (
972     short operator,
973     java.util.Collection   values
974   ) {
975     refAddValue(
976       "org:opencrx:kernel:generic:CrxObject:disabledReason",
977       org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
978       operator,
979       values
980     );
981   }
982 
983   public void thereExistsDisabledReason (
984     short operator,
985     java.util.Collection   values
986   ) {
987     refAddValue(
988       "org:opencrx:kernel:generic:CrxObject:disabledReason",
989       org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
990       operator,
991       values
992     );
993   }
994 
995   public void forAllDisabledReason (
996     short operator,
997     String  [] filterValues
998   ) {
999     java.util.List   arrayAsList = new java.util.ArrayList  ();
1000    for(int i = 0; i < filterValues.length; i++) {
1001      arrayAsList.add(
1002        filterValues[i]
1003      );
1004    }
1005    forAllDisabledReason (
1006      operator,
1007      arrayAsList
1008    );
1009  }
1010
1011  public void thereExistsDisabledReason (
1012    short operator,
1013    String  [] filterValues
1014  ) {
1015    java.util.List   arrayAsList = new java.util.ArrayList  ();
1016    for(int i = 0; i < filterValues.length; i++) {
1017      arrayAsList.add(
1018        filterValues[i]
1019      );
1020    }
1021    thereExistsDisabledReason (
1022      operator,
1023      arrayAsList
1024    );
1025  }
1026
1027  public void orderByDisabledReason (
1028    short order
1029  ) {
1030    refAddValue(
1031      "org:opencrx:kernel:generic:CrxObject:disabledReason",
1032      order
1033    );
1034  }
1035      
1036// ----------------------------------------------------------------------------
1037// Filter/ImplAttributeIsNotStruct
1038// ----------------------------------------------------------------------------
1039  public void forAllExternalLink (
1040    short operator,
1041    java.util.Collection   values
1042  ) {
1043    refAddValue(
1044      "org:opencrx:kernel:generic:CrxObject:externalLink",
1045      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1046      operator,
1047      values
1048    );
1049  }
1050
1051  public void thereExistsExternalLink (
1052    short operator,
1053    java.util.Collection   values
1054  ) {
1055    refAddValue(
1056      "org:opencrx:kernel:generic:CrxObject:externalLink",
1057      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1058      operator,
1059      values
1060    );
1061  }
1062
1063  public void forAllExternalLink (
1064    short operator,
1065    String  [] filterValues
1066  ) {
1067    java.util.List   arrayAsList = new java.util.ArrayList  ();
1068    for(int i = 0; i < filterValues.length; i++) {
1069      arrayAsList.add(
1070        filterValues[i]
1071      );
1072    }
1073    forAllExternalLink (
1074      operator,
1075      arrayAsList
1076    );
1077  }
1078
1079  public void thereExistsExternalLink (
1080    short operator,
1081    String  [] filterValues
1082  ) {
1083    java.util.List   arrayAsList = new java.util.ArrayList  ();
1084    for(int i = 0; i < filterValues.length; i++) {
1085      arrayAsList.add(
1086        filterValues[i]
1087      );
1088    }
1089    thereExistsExternalLink (
1090      operator,
1091      arrayAsList
1092    );
1093  }
1094
1095  public void orderByExternalLink (
1096    short order
1097  ) {
1098    refAddValue(
1099      "org:opencrx:kernel:generic:CrxObject:externalLink",
1100      order
1101    );
1102  }
1103      
1104// ----------------------------------------------------------------------------
1105// Filter/ImplAttributeIsNotStruct
1106// ----------------------------------------------------------------------------
1107  public void forAllUserBoolean0 (
1108    short operator,
1109    java.util.Collection   values
1110  ) {
1111    refAddValue(
1112      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1113      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1114      operator,
1115      values
1116    );
1117  }
1118
1119  public void thereExistsUserBoolean0 (
1120    short operator,
1121    java.util.Collection   values
1122  ) {
1123    refAddValue(
1124      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1125      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1126      operator,
1127      values
1128    );
1129  }
1130
1131  public void forAllUserBoolean0 (
1132    short operator,
1133    boolean[] filterValues
1134  ) {
1135    java.util.List   arrayAsList = new java.util.ArrayList  ();
1136    for(int i = 0; i < filterValues.length; i++) {
1137      arrayAsList.add(
1138        new Boolean  (filterValues[i])
1139      );
1140    }
1141    forAllUserBoolean0 (
1142      operator,
1143      arrayAsList
1144    );
1145  }
1146
1147  public void thereExistsUserBoolean0 (
1148    short operator,
1149    boolean[] filterValues
1150  ) {
1151    java.util.List   arrayAsList = new java.util.ArrayList  ();
1152    for(int i = 0; i < filterValues.length; i++) {
1153      arrayAsList.add(
1154        new Boolean  (filterValues[i])
1155      );
1156    }
1157    thereExistsUserBoolean0 (
1158      operator,
1159      arrayAsList
1160    );
1161  }
1162
1163  public void orderByUserBoolean0 (
1164    short order
1165  ) {
1166    refAddValue(
1167      "org:opencrx:kernel:generic:CrxObject:userBoolean0",
1168      order
1169    );
1170  }
1171      
1172// ----------------------------------------------------------------------------
1173// Filter/ImplAttributeIsNotStruct
1174// ----------------------------------------------------------------------------
1175  public void forAllUserBoolean1 (
1176    short operator,
1177    java.util.Collection   values
1178  ) {
1179    refAddValue(
1180      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1181      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1182      operator,
1183      values
1184    );
1185  }
1186
1187  public void thereExistsUserBoolean1 (
1188    short operator,
1189    java.util.Collection   values
1190  ) {
1191    refAddValue(
1192      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1193      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1194      operator,
1195      values
1196    );
1197  }
1198
1199  public void forAllUserBoolean1 (
1200    short operator,
1201    boolean[] filterValues
1202  ) {
1203    java.util.List   arrayAsList = new java.util.ArrayList  ();
1204    for(int i = 0; i < filterValues.length; i++) {
1205      arrayAsList.add(
1206        new Boolean  (filterValues[i])
1207      );
1208    }
1209    forAllUserBoolean1 (
1210      operator,
1211      arrayAsList
1212    );
1213  }
1214
1215  public void thereExistsUserBoolean1 (
1216    short operator,
1217    boolean[] filterValues
1218  ) {
1219    java.util.List   arrayAsList = new java.util.ArrayList  ();
1220    for(int i = 0; i < filterValues.length; i++) {
1221      arrayAsList.add(
1222        new Boolean  (filterValues[i])
1223      );
1224    }
1225    thereExistsUserBoolean1 (
1226      operator,
1227      arrayAsList
1228    );
1229  }
1230
1231  public void orderByUserBoolean1 (
1232    short order
1233  ) {
1234    refAddValue(
1235      "org:opencrx:kernel:generic:CrxObject:userBoolean1",
1236      order
1237    );
1238  }
1239      
1240// ----------------------------------------------------------------------------
1241// Filter/ImplAttributeIsNotStruct
1242// ----------------------------------------------------------------------------
1243  public void forAllUserBoolean2 (
1244    short operator,
1245    java.util.Collection   values
1246  ) {
1247    refAddValue(
1248      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1249      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1250      operator,
1251      values
1252    );
1253  }
1254
1255  public void thereExistsUserBoolean2 (
1256    short operator,
1257    java.util.Collection   values
1258  ) {
1259    refAddValue(
1260      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1261      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1262      operator,
1263      values
1264    );
1265  }
1266
1267  public void forAllUserBoolean2 (
1268    short operator,
1269    boolean[] filterValues
1270  ) {
1271    java.util.List   arrayAsList = new java.util.ArrayList  ();
1272    for(int i = 0; i < filterValues.length; i++) {
1273      arrayAsList.add(
1274        new Boolean  (filterValues[i])
1275      );
1276    }
1277    forAllUserBoolean2 (
1278      operator,
1279      arrayAsList
1280    );
1281  }
1282
1283  public void thereExistsUserBoolean2 (
1284    short operator,
1285    boolean[] filterValues
1286  ) {
1287    java.util.List   arrayAsList = new java.util.ArrayList  ();
1288    for(int i = 0; i < filterValues.length; i++) {
1289      arrayAsList.add(
1290        new Boolean  (filterValues[i])
1291      );
1292    }
1293    thereExistsUserBoolean2 (
1294      operator,
1295      arrayAsList
1296    );
1297  }
1298
1299  public void orderByUserBoolean2 (
1300    short order
1301  ) {
1302    refAddValue(
1303      "org:opencrx:kernel:generic:CrxObject:userBoolean2",
1304      order
1305    );
1306  }
1307      
1308// ----------------------------------------------------------------------------
1309// Filter/ImplAttributeIsNotStruct
1310// ----------------------------------------------------------------------------
1311  public void forAllUserBoolean3 (
1312    short operator,
1313    java.util.Collection   values
1314  ) {
1315    refAddValue(
1316      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1317      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1318      operator,
1319      values
1320    );
1321  }
1322
1323  public void thereExistsUserBoolean3 (
1324    short operator,
1325    java.util.Collection   values
1326  ) {
1327    refAddValue(
1328      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1329      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1330      operator,
1331      values
1332    );
1333  }
1334
1335  public void forAllUserBoolean3 (
1336    short operator,
1337    boolean[] filterValues
1338  ) {
1339    java.util.List   arrayAsList = new java.util.ArrayList  ();
1340    for(int i = 0; i < filterValues.length; i++) {
1341      arrayAsList.add(
1342        new Boolean  (filterValues[i])
1343      );
1344    }
1345    forAllUserBoolean3 (
1346      operator,
1347      arrayAsList
1348    );
1349  }
1350
1351  public void thereExistsUserBoolean3 (
1352    short operator,
1353    boolean[] filterValues
1354  ) {
1355    java.util.List   arrayAsList = new java.util.ArrayList  ();
1356    for(int i = 0; i < filterValues.length; i++) {
1357      arrayAsList.add(
1358        new Boolean  (filterValues[i])
1359      );
1360    }
1361    thereExistsUserBoolean3 (
1362      operator,
1363      arrayAsList
1364    );
1365  }
1366
1367  public void orderByUserBoolean3 (
1368    short order
1369  ) {
1370    refAddValue(
1371      "org:opencrx:kernel:generic:CrxObject:userBoolean3",
1372      order
1373    );
1374  }
1375      
1376// ----------------------------------------------------------------------------
1377// Filter/ImplAttributeIsNotStruct
1378// ----------------------------------------------------------------------------
1379  public void forAllUserBoolean4 (
1380    short operator,
1381    java.util.Collection   values
1382  ) {
1383    refAddValue(
1384      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1385      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1386      operator,
1387      values
1388    );
1389  }
1390
1391  public void thereExistsUserBoolean4 (
1392    short operator,
1393    java.util.Collection   values
1394  ) {
1395    refAddValue(
1396      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1397      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1398      operator,
1399      values
1400    );
1401  }
1402
1403  public void forAllUserBoolean4 (
1404    short operator,
1405    boolean[] filterValues
1406  ) {
1407    java.util.List   arrayAsList = new java.util.ArrayList  ();
1408    for(int i = 0; i < filterValues.length; i++) {
1409      arrayAsList.add(
1410        new Boolean  (filterValues[i])
1411      );
1412    }
1413    forAllUserBoolean4 (
1414      operator,
1415      arrayAsList
1416    );
1417  }
1418
1419  public void thereExistsUserBoolean4 (
1420    short operator,
1421    boolean[] filterValues
1422  ) {
1423    java.util.List   arrayAsList = new java.util.ArrayList  ();
1424    for(int i = 0; i < filterValues.length; i++) {
1425      arrayAsList.add(
1426        new Boolean  (filterValues[i])
1427      );
1428    }
1429    thereExistsUserBoolean4 (
1430      operator,
1431      arrayAsList
1432    );
1433  }
1434
1435  public void orderByUserBoolean4 (
1436    short order
1437  ) {
1438    refAddValue(
1439      "org:opencrx:kernel:generic:CrxObject:userBoolean4",
1440      order
1441    );
1442  }
1443      
1444// ----------------------------------------------------------------------------
1445// Filter/ImplAttributeIsNotStruct
1446// ----------------------------------------------------------------------------
1447  public void forAllUserCode0 (
1448    short operator,
1449    java.util.Collection   values
1450  ) {
1451    refAddValue(
1452      "org:opencrx:kernel:generic:CrxObject:userCode0",
1453      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1454      operator,
1455      values
1456    );
1457  }
1458
1459  public void thereExistsUserCode0 (
1460    short operator,
1461    java.util.Collection   values
1462  ) {
1463    refAddValue(
1464      "org:opencrx:kernel:generic:CrxObject:userCode0",
1465      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1466      operator,
1467      values
1468    );
1469  }
1470
1471  public void forAllUserCode0 (
1472    short operator,
1473    short[] filterValues
1474  ) {
1475    java.util.List   arrayAsList = new java.util.ArrayList  ();
1476    for(int i = 0; i < filterValues.length; i++) {
1477      arrayAsList.add(
1478        new Short  (filterValues[i])
1479      );
1480    }
1481    forAllUserCode0 (
1482      operator,
1483      arrayAsList
1484    );
1485  }
1486
1487  public void thereExistsUserCode0 (
1488    short operator,
1489    short[] filterValues
1490  ) {
1491    java.util.List   arrayAsList = new java.util.ArrayList  ();
1492    for(int i = 0; i < filterValues.length; i++) {
1493      arrayAsList.add(
1494        new Short  (filterValues[i])
1495      );
1496    }
1497    thereExistsUserCode0 (
1498      operator,
1499      arrayAsList
1500    );
1501  }
1502
1503  public void orderByUserCode0 (
1504    short order
1505  ) {
1506    refAddValue(
1507      "org:opencrx:kernel:generic:CrxObject:userCode0",
1508      order
1509    );
1510  }
1511      
1512// ----------------------------------------------------------------------------
1513// Filter/ImplAttributeIsNotStruct
1514// ----------------------------------------------------------------------------
1515  public void forAllUserCode1 (
1516    short operator,
1517    java.util.Collection   values
1518  ) {
1519    refAddValue(
1520      "org:opencrx:kernel:generic:CrxObject:userCode1",
1521      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1522      operator,
1523      values
1524    );
1525  }
1526
1527  public void thereExistsUserCode1 (
1528    short operator,
1529    java.util.Collection   values
1530  ) {
1531    refAddValue(
1532      "org:opencrx:kernel:generic:CrxObject:userCode1",
1533      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1534      operator,
1535      values
1536    );
1537  }
1538
1539  public void forAllUserCode1 (
1540    short operator,
1541    short[] filterValues
1542  ) {
1543    java.util.List   arrayAsList = new java.util.ArrayList  ();
1544    for(int i = 0; i < filterValues.length; i++) {
1545      arrayAsList.add(
1546        new Short  (filterValues[i])
1547      );
1548    }
1549    forAllUserCode1 (
1550      operator,
1551      arrayAsList
1552    );
1553  }
1554
1555  public void thereExistsUserCode1 (
1556    short operator,
1557    short[] filterValues
1558  ) {
1559    java.util.List   arrayAsList = new java.util.ArrayList  ();
1560    for(int i = 0; i < filterValues.length; i++) {
1561      arrayAsList.add(
1562        new Short  (filterValues[i])
1563      );
1564    }
1565    thereExistsUserCode1 (
1566      operator,
1567      arrayAsList
1568    );
1569  }
1570
1571  public void orderByUserCode1 (
1572    short order
1573  ) {
1574    refAddValue(
1575      "org:opencrx:kernel:generic:CrxObject:userCode1",
1576      order
1577    );
1578  }
1579      
1580// ----------------------------------------------------------------------------
1581// Filter/ImplAttributeIsNotStruct
1582// ----------------------------------------------------------------------------
1583  public void forAllUserCode2 (
1584    short operator,
1585    java.util.Collection   values
1586  ) {
1587    refAddValue(
1588      "org:opencrx:kernel:generic:CrxObject:userCode2",
1589      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1590      operator,
1591      values
1592    );
1593  }
1594
1595  public void thereExistsUserCode2 (
1596    short operator,
1597    java.util.Collection   values
1598  ) {
1599    refAddValue(
1600      "org:opencrx:kernel:generic:CrxObject:userCode2",
1601      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1602      operator,
1603      values
1604    );
1605  }
1606
1607  public void forAllUserCode2 (
1608    short operator,
1609    short[] filterValues
1610  ) {
1611    java.util.List   arrayAsList = new java.util.ArrayList  ();
1612    for(int i = 0; i < filterValues.length; i++) {
1613      arrayAsList.add(
1614        new Short  (filterValues[i])
1615      );
1616    }
1617    forAllUserCode2 (
1618      operator,
1619      arrayAsList
1620    );
1621  }
1622
1623  public void thereExistsUserCode2 (
1624    short operator,
1625    short[] filterValues
1626  ) {
1627    java.util.List   arrayAsList = new java.util.ArrayList  ();
1628    for(int i = 0; i < filterValues.length; i++) {
1629      arrayAsList.add(
1630        new Short  (filterValues[i])
1631      );
1632    }
1633    thereExistsUserCode2 (
1634      operator,
1635      arrayAsList
1636    );
1637  }
1638
1639  public void orderByUserCode2 (
1640    short order
1641  ) {
1642    refAddValue(
1643      "org:opencrx:kernel:generic:CrxObject:userCode2",
1644      order
1645    );
1646  }
1647      
1648// ----------------------------------------------------------------------------
1649// Filter/ImplAttributeIsNotStruct
1650// ----------------------------------------------------------------------------
1651  public void forAllUserCode3 (
1652    short operator,
1653    java.util.Collection   values
1654  ) {
1655    refAddValue(
1656      "org:opencrx:kernel:generic:CrxObject:userCode3",
1657      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1658      operator,
1659      values
1660    );
1661  }
1662
1663  public void thereExistsUserCode3 (
1664    short operator,
1665    java.util.Collection   values
1666  ) {
1667    refAddValue(
1668      "org:opencrx:kernel:generic:CrxObject:userCode3",
1669      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1670      operator,
1671      values
1672    );
1673  }
1674
1675  public void forAllUserCode3 (
1676    short operator,
1677    short[] filterValues
1678  ) {
1679    java.util.List   arrayAsList = new java.util.ArrayList  ();
1680    for(int i = 0; i < filterValues.length; i++) {
1681      arrayAsList.add(
1682        new Short  (filterValues[i])
1683      );
1684    }
1685    forAllUserCode3 (
1686      operator,
1687      arrayAsList
1688    );
1689  }
1690
1691  public void thereExistsUserCode3 (
1692    short operator,
1693    short[] filterValues
1694  ) {
1695    java.util.List   arrayAsList = new java.util.ArrayList  ();
1696    for(int i = 0; i < filterValues.length; i++) {
1697      arrayAsList.add(
1698        new Short  (filterValues[i])
1699      );
1700    }
1701    thereExistsUserCode3 (
1702      operator,
1703      arrayAsList
1704    );
1705  }
1706
1707  public void orderByUserCode3 (
1708    short order
1709  ) {
1710    refAddValue(
1711      "org:opencrx:kernel:generic:CrxObject:userCode3",
1712      order
1713    );
1714  }
1715      
1716// ----------------------------------------------------------------------------
1717// Filter/ImplAttributeIsNotStruct
1718// ----------------------------------------------------------------------------
1719  public void forAllUserCode4 (
1720    short operator,
1721    java.util.Collection   values
1722  ) {
1723    refAddValue(
1724      "org:opencrx:kernel:generic:CrxObject:userCode4",
1725      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1726      operator,
1727      values
1728    );
1729  }
1730
1731  public void thereExistsUserCode4 (
1732    short operator,
1733    java.util.Collection   values
1734  ) {
1735    refAddValue(
1736      "org:opencrx:kernel:generic:CrxObject:userCode4",
1737      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1738      operator,
1739      values
1740    );
1741  }
1742
1743  public void forAllUserCode4 (
1744    short operator,
1745    short[] filterValues
1746  ) {
1747    java.util.List   arrayAsList = new java.util.ArrayList  ();
1748    for(int i = 0; i < filterValues.length; i++) {
1749      arrayAsList.add(
1750        new Short  (filterValues[i])
1751      );
1752    }
1753    forAllUserCode4 (
1754      operator,
1755      arrayAsList
1756    );
1757  }
1758
1759  public void thereExistsUserCode4 (
1760    short operator,
1761    short[] filterValues
1762  ) {
1763    java.util.List   arrayAsList = new java.util.ArrayList  ();
1764    for(int i = 0; i < filterValues.length; i++) {
1765      arrayAsList.add(
1766        new Short  (filterValues[i])
1767      );
1768    }
1769    thereExistsUserCode4 (
1770      operator,
1771      arrayAsList
1772    );
1773  }
1774
1775  public void orderByUserCode4 (
1776    short order
1777  ) {
1778    refAddValue(
1779      "org:opencrx:kernel:generic:CrxObject:userCode4",
1780      order
1781    );
1782  }
1783      
1784// ----------------------------------------------------------------------------
1785// Filter/ImplAttributeIsNotStruct
1786// ----------------------------------------------------------------------------
1787  public void forAllUserDate0 (
1788    short operator,
1789    java.util.Collection   values
1790  ) {
1791    refAddValue(
1792      "org:opencrx:kernel:generic:CrxObject:userDate0",
1793      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1794      operator,
1795      values
1796    );
1797  }
1798
1799  public void thereExistsUserDate0 (
1800    short operator,
1801    java.util.Collection   values
1802  ) {
1803    refAddValue(
1804      "org:opencrx:kernel:generic:CrxObject:userDate0",
1805      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1806      operator,
1807      values
1808    );
1809  }
1810
1811  public void forAllUserDate0 (
1812    short operator,
1813    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1814  ) {
1815    java.util.List   arrayAsList = new java.util.ArrayList  ();
1816    for(int i = 0; i < filterValues.length; i++) {
1817      arrayAsList.add(
1818        filterValues[i]
1819      );
1820    }
1821    forAllUserDate0 (
1822      operator,
1823      arrayAsList
1824    );
1825  }
1826
1827  public void thereExistsUserDate0 (
1828    short operator,
1829    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1830  ) {
1831    java.util.List   arrayAsList = new java.util.ArrayList  ();
1832    for(int i = 0; i < filterValues.length; i++) {
1833      arrayAsList.add(
1834        filterValues[i]
1835      );
1836    }
1837    thereExistsUserDate0 (
1838      operator,
1839      arrayAsList
1840    );
1841  }
1842
1843  public void orderByUserDate0 (
1844    short order
1845  ) {
1846    refAddValue(
1847      "org:opencrx:kernel:generic:CrxObject:userDate0",
1848      order
1849    );
1850  }
1851      
1852// ----------------------------------------------------------------------------
1853// Filter/ImplAttributeIsNotStruct
1854// ----------------------------------------------------------------------------
1855  public void forAllUserDate1 (
1856    short operator,
1857    java.util.Collection   values
1858  ) {
1859    refAddValue(
1860      "org:opencrx:kernel:generic:CrxObject:userDate1",
1861      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1862      operator,
1863      values
1864    );
1865  }
1866
1867  public void thereExistsUserDate1 (
1868    short operator,
1869    java.util.Collection   values
1870  ) {
1871    refAddValue(
1872      "org:opencrx:kernel:generic:CrxObject:userDate1",
1873      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1874      operator,
1875      values
1876    );
1877  }
1878
1879  public void forAllUserDate1 (
1880    short operator,
1881    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1882  ) {
1883    java.util.List   arrayAsList = new java.util.ArrayList  ();
1884    for(int i = 0; i < filterValues.length; i++) {
1885      arrayAsList.add(
1886        filterValues[i]
1887      );
1888    }
1889    forAllUserDate1 (
1890      operator,
1891      arrayAsList
1892    );
1893  }
1894
1895  public void thereExistsUserDate1 (
1896    short operator,
1897    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1898  ) {
1899    java.util.List   arrayAsList = new java.util.ArrayList  ();
1900    for(int i = 0; i < filterValues.length; i++) {
1901      arrayAsList.add(
1902        filterValues[i]
1903      );
1904    }
1905    thereExistsUserDate1 (
1906      operator,
1907      arrayAsList
1908    );
1909  }
1910
1911  public void orderByUserDate1 (
1912    short order
1913  ) {
1914    refAddValue(
1915      "org:opencrx:kernel:generic:CrxObject:userDate1",
1916      order
1917    );
1918  }
1919      
1920// ----------------------------------------------------------------------------
1921// Filter/ImplAttributeIsNotStruct
1922// ----------------------------------------------------------------------------
1923  public void forAllUserDate2 (
1924    short operator,
1925    java.util.Collection   values
1926  ) {
1927    refAddValue(
1928      "org:opencrx:kernel:generic:CrxObject:userDate2",
1929      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1930      operator,
1931      values
1932    );
1933  }
1934
1935  public void thereExistsUserDate2 (
1936    short operator,
1937    java.util.Collection   values
1938  ) {
1939    refAddValue(
1940      "org:opencrx:kernel:generic:CrxObject:userDate2",
1941      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
1942      operator,
1943      values
1944    );
1945  }
1946
1947  public void forAllUserDate2 (
1948    short operator,
1949    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1950  ) {
1951    java.util.List   arrayAsList = new java.util.ArrayList  ();
1952    for(int i = 0; i < filterValues.length; i++) {
1953      arrayAsList.add(
1954        filterValues[i]
1955      );
1956    }
1957    forAllUserDate2 (
1958      operator,
1959      arrayAsList
1960    );
1961  }
1962
1963  public void thereExistsUserDate2 (
1964    short operator,
1965    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
1966  ) {
1967    java.util.List   arrayAsList = new java.util.ArrayList  ();
1968    for(int i = 0; i < filterValues.length; i++) {
1969      arrayAsList.add(
1970        filterValues[i]
1971      );
1972    }
1973    thereExistsUserDate2 (
1974      operator,
1975      arrayAsList
1976    );
1977  }
1978
1979  public void orderByUserDate2 (
1980    short order
1981  ) {
1982    refAddValue(
1983      "org:opencrx:kernel:generic:CrxObject:userDate2",
1984      order
1985    );
1986  }
1987      
1988// ----------------------------------------------------------------------------
1989// Filter/ImplAttributeIsNotStruct
1990// ----------------------------------------------------------------------------
1991  public void forAllUserDate3 (
1992    short operator,
1993    java.util.Collection   values
1994  ) {
1995    refAddValue(
1996      "org:opencrx:kernel:generic:CrxObject:userDate3",
1997      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
1998      operator,
1999      values
2000    );
2001  }
2002
2003  public void thereExistsUserDate3 (
2004    short operator,
2005    java.util.Collection   values
2006  ) {
2007    refAddValue(
2008      "org:opencrx:kernel:generic:CrxObject:userDate3",
2009      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2010      operator,
2011      values
2012    );
2013  }
2014
2015  public void forAllUserDate3 (
2016    short operator,
2017    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2018  ) {
2019    java.util.List   arrayAsList = new java.util.ArrayList  ();
2020    for(int i = 0; i < filterValues.length; i++) {
2021      arrayAsList.add(
2022        filterValues[i]
2023      );
2024    }
2025    forAllUserDate3 (
2026      operator,
2027      arrayAsList
2028    );
2029  }
2030
2031  public void thereExistsUserDate3 (
2032    short operator,
2033    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2034  ) {
2035    java.util.List   arrayAsList = new java.util.ArrayList  ();
2036    for(int i = 0; i < filterValues.length; i++) {
2037      arrayAsList.add(
2038        filterValues[i]
2039      );
2040    }
2041    thereExistsUserDate3 (
2042      operator,
2043      arrayAsList
2044    );
2045  }
2046
2047  public void orderByUserDate3 (
2048    short order
2049  ) {
2050    refAddValue(
2051      "org:opencrx:kernel:generic:CrxObject:userDate3",
2052      order
2053    );
2054  }
2055      
2056// ----------------------------------------------------------------------------
2057// Filter/ImplAttributeIsNotStruct
2058// ----------------------------------------------------------------------------
2059  public void forAllUserDate4 (
2060    short operator,
2061    java.util.Collection   values
2062  ) {
2063    refAddValue(
2064      "org:opencrx:kernel:generic:CrxObject:userDate4",
2065      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2066      operator,
2067      values
2068    );
2069  }
2070
2071  public void thereExistsUserDate4 (
2072    short operator,
2073    java.util.Collection   values
2074  ) {
2075    refAddValue(
2076      "org:opencrx:kernel:generic:CrxObject:userDate4",
2077      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2078      operator,
2079      values
2080    );
2081  }
2082
2083  public void forAllUserDate4 (
2084    short operator,
2085    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2086  ) {
2087    java.util.List   arrayAsList = new java.util.ArrayList  ();
2088    for(int i = 0; i < filterValues.length; i++) {
2089      arrayAsList.add(
2090        filterValues[i]
2091      );
2092    }
2093    forAllUserDate4 (
2094      operator,
2095      arrayAsList
2096    );
2097  }
2098
2099  public void thereExistsUserDate4 (
2100    short operator,
2101    org.openmdx.uses.javax.xml.datatype.XMLGregorianCalendar[] filterValues
2102  ) {
2103    java.util.List   arrayAsList = new java.util.ArrayList  ();
2104    for(int i = 0; i < filterValues.length; i++) {
2105      arrayAsList.add(
2106        filterValues[i]
2107      );
2108    }
2109    thereExistsUserDate4 (
2110      operator,
2111      arrayAsList
2112    );
2113  }
2114
2115  public void orderByUserDate4 (
2116    short order
2117  ) {
2118    refAddValue(
2119      "org:opencrx:kernel:generic:CrxObject:userDate4",
2120      order
2121    );
2122  }
2123      
2124// ----------------------------------------------------------------------------
2125// Filter/ImplAttributeIsNotStruct
2126// ----------------------------------------------------------------------------
2127  public void forAllUserDateTime0 (
2128    short operator,
2129    java.util.Collection   values
2130  ) {
2131    refAddValue(
2132      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2133      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2134      operator,
2135      values
2136    );
2137  }
2138
2139  public void thereExistsUserDateTime0 (
2140    short operator,
2141    java.util.Collection   values
2142  ) {
2143    refAddValue(
2144      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2145      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2146      operator,
2147      values
2148    );
2149  }
2150
2151  public void forAllUserDateTime0 (
2152    short operator,
2153    java.util.Date  [] filterValues
2154  ) {
2155    java.util.List   arrayAsList = new java.util.ArrayList  ();
2156    for(int i = 0; i < filterValues.length; i++) {
2157      arrayAsList.add(
2158        filterValues[i]
2159      );
2160    }
2161    forAllUserDateTime0 (
2162      operator,
2163      arrayAsList
2164    );
2165  }
2166
2167  public void thereExistsUserDateTime0 (
2168    short operator,
2169    java.util.Date  [] filterValues
2170  ) {
2171    java.util.List   arrayAsList = new java.util.ArrayList  ();
2172    for(int i = 0; i < filterValues.length; i++) {
2173      arrayAsList.add(
2174        filterValues[i]
2175      );
2176    }
2177    thereExistsUserDateTime0 (
2178      operator,
2179      arrayAsList
2180    );
2181  }
2182
2183  public void orderByUserDateTime0 (
2184    short order
2185  ) {
2186    refAddValue(
2187      "org:opencrx:kernel:generic:CrxObject:userDateTime0",
2188      order
2189    );
2190  }
2191      
2192// ----------------------------------------------------------------------------
2193// Filter/ImplAttributeIsNotStruct
2194// ----------------------------------------------------------------------------
2195  public void forAllUserDateTime1 (
2196    short operator,
2197    java.util.Collection   values
2198  ) {
2199    refAddValue(
2200      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2201      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2202      operator,
2203      values
2204    );
2205  }
2206
2207  public void thereExistsUserDateTime1 (
2208    short operator,
2209    java.util.Collection   values
2210  ) {
2211    refAddValue(
2212      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2213      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2214      operator,
2215      values
2216    );
2217  }
2218
2219  public void forAllUserDateTime1 (
2220    short operator,
2221    java.util.Date  [] filterValues
2222  ) {
2223    java.util.List   arrayAsList = new java.util.ArrayList  ();
2224    for(int i = 0; i < filterValues.length; i++) {
2225      arrayAsList.add(
2226        filterValues[i]
2227      );
2228    }
2229    forAllUserDateTime1 (
2230      operator,
2231      arrayAsList
2232    );
2233  }
2234
2235  public void thereExistsUserDateTime1 (
2236    short operator,
2237    java.util.Date  [] filterValues
2238  ) {
2239    java.util.List   arrayAsList = new java.util.ArrayList  ();
2240    for(int i = 0; i < filterValues.length; i++) {
2241      arrayAsList.add(
2242        filterValues[i]
2243      );
2244    }
2245    thereExistsUserDateTime1 (
2246      operator,
2247      arrayAsList
2248    );
2249  }
2250
2251  public void orderByUserDateTime1 (
2252    short order
2253  ) {
2254    refAddValue(
2255      "org:opencrx:kernel:generic:CrxObject:userDateTime1",
2256      order
2257    );
2258  }
2259      
2260// ----------------------------------------------------------------------------
2261// Filter/ImplAttributeIsNotStruct
2262// ----------------------------------------------------------------------------
2263  public void forAllUserDateTime2 (
2264    short operator,
2265    java.util.Collection   values
2266  ) {
2267    refAddValue(
2268      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2269      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2270      operator,
2271      values
2272    );
2273  }
2274
2275  public void thereExistsUserDateTime2 (
2276    short operator,
2277    java.util.Collection   values
2278  ) {
2279    refAddValue(
2280      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2281      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2282      operator,
2283      values
2284    );
2285  }
2286
2287  public void forAllUserDateTime2 (
2288    short operator,
2289    java.util.Date  [] filterValues
2290  ) {
2291    java.util.List   arrayAsList = new java.util.ArrayList  ();
2292    for(int i = 0; i < filterValues.length; i++) {
2293      arrayAsList.add(
2294        filterValues[i]
2295      );
2296    }
2297    forAllUserDateTime2 (
2298      operator,
2299      arrayAsList
2300    );
2301  }
2302
2303  public void thereExistsUserDateTime2 (
2304    short operator,
2305    java.util.Date  [] filterValues
2306  ) {
2307    java.util.List   arrayAsList = new java.util.ArrayList  ();
2308    for(int i = 0; i < filterValues.length; i++) {
2309      arrayAsList.add(
2310        filterValues[i]
2311      );
2312    }
2313    thereExistsUserDateTime2 (
2314      operator,
2315      arrayAsList
2316    );
2317  }
2318
2319  public void orderByUserDateTime2 (
2320    short order
2321  ) {
2322    refAddValue(
2323      "org:opencrx:kernel:generic:CrxObject:userDateTime2",
2324      order
2325    );
2326  }
2327      
2328// ----------------------------------------------------------------------------
2329// Filter/ImplAttributeIsNotStruct
2330// ----------------------------------------------------------------------------
2331  public void forAllUserDateTime3 (
2332    short operator,
2333    java.util.Collection   values
2334  ) {
2335    refAddValue(
2336      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2337      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2338      operator,
2339      values
2340    );
2341  }
2342
2343  public void thereExistsUserDateTime3 (
2344    short operator,
2345    java.util.Collection   values
2346  ) {
2347    refAddValue(
2348      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2349      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2350      operator,
2351      values
2352    );
2353  }
2354
2355  public void forAllUserDateTime3 (
2356    short operator,
2357    java.util.Date  [] filterValues
2358  ) {
2359    java.util.List   arrayAsList = new java.util.ArrayList  ();
2360    for(int i = 0; i < filterValues.length; i++) {
2361      arrayAsList.add(
2362        filterValues[i]
2363      );
2364    }
2365    forAllUserDateTime3 (
2366      operator,
2367      arrayAsList
2368    );
2369  }
2370
2371  public void thereExistsUserDateTime3 (
2372    short operator,
2373    java.util.Date  [] filterValues
2374  ) {
2375    java.util.List   arrayAsList = new java.util.ArrayList  ();
2376    for(int i = 0; i < filterValues.length; i++) {
2377      arrayAsList.add(
2378        filterValues[i]
2379      );
2380    }
2381    thereExistsUserDateTime3 (
2382      operator,
2383      arrayAsList
2384    );
2385  }
2386
2387  public void orderByUserDateTime3 (
2388    short order
2389  ) {
2390    refAddValue(
2391      "org:opencrx:kernel:generic:CrxObject:userDateTime3",
2392      order
2393    );
2394  }
2395      
2396// ----------------------------------------------------------------------------
2397// Filter/ImplAttributeIsNotStruct
2398// ----------------------------------------------------------------------------
2399  public void forAllUserDateTime4 (
2400    short operator,
2401    java.util.Collection   values
2402  ) {
2403    refAddValue(
2404      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2405      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2406      operator,
2407      values
2408    );
2409  }
2410
2411  public void thereExistsUserDateTime4 (
2412    short operator,
2413    java.util.Collection   values
2414  ) {
2415    refAddValue(
2416      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2417      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2418      operator,
2419      values
2420    );
2421  }
2422
2423  public void forAllUserDateTime4 (
2424    short operator,
2425    java.util.Date  [] filterValues
2426  ) {
2427    java.util.List   arrayAsList = new java.util.ArrayList  ();
2428    for(int i = 0; i < filterValues.length; i++) {
2429      arrayAsList.add(
2430        filterValues[i]
2431      );
2432    }
2433    forAllUserDateTime4 (
2434      operator,
2435      arrayAsList
2436    );
2437  }
2438
2439  public void thereExistsUserDateTime4 (
2440    short operator,
2441    java.util.Date  [] filterValues
2442  ) {
2443    java.util.List   arrayAsList = new java.util.ArrayList  ();
2444    for(int i = 0; i < filterValues.length; i++) {
2445      arrayAsList.add(
2446        filterValues[i]
2447      );
2448    }
2449    thereExistsUserDateTime4 (
2450      operator,
2451      arrayAsList
2452    );
2453  }
2454
2455  public void orderByUserDateTime4 (
2456    short order
2457  ) {
2458    refAddValue(
2459      "org:opencrx:kernel:generic:CrxObject:userDateTime4",
2460      order
2461    );
2462  }
2463      
2464// ----------------------------------------------------------------------------
2465// Filter/ImplAttributeIsNotStruct
2466// ----------------------------------------------------------------------------
2467  public void forAllUserNumber0 (
2468    short operator,
2469    java.util.Collection   values
2470  ) {
2471    refAddValue(
2472      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2473      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2474      operator,
2475      values
2476    );
2477  }
2478
2479  public void thereExistsUserNumber0 (
2480    short operator,
2481    java.util.Collection   values
2482  ) {
2483    refAddValue(
2484      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2485      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2486      operator,
2487      values
2488    );
2489  }
2490
2491  public void forAllUserNumber0 (
2492    short operator,
2493    java.math.BigDecimal  [] filterValues
2494  ) {
2495    java.util.List   arrayAsList = new java.util.ArrayList  ();
2496    for(int i = 0; i < filterValues.length; i++) {
2497      arrayAsList.add(
2498        filterValues[i]
2499      );
2500    }
2501    forAllUserNumber0 (
2502      operator,
2503      arrayAsList
2504    );
2505  }
2506
2507  public void thereExistsUserNumber0 (
2508    short operator,
2509    java.math.BigDecimal  [] filterValues
2510  ) {
2511    java.util.List   arrayAsList = new java.util.ArrayList  ();
2512    for(int i = 0; i < filterValues.length; i++) {
2513      arrayAsList.add(
2514        filterValues[i]
2515      );
2516    }
2517    thereExistsUserNumber0 (
2518      operator,
2519      arrayAsList
2520    );
2521  }
2522
2523  public void orderByUserNumber0 (
2524    short order
2525  ) {
2526    refAddValue(
2527      "org:opencrx:kernel:generic:CrxObject:userNumber0",
2528      order
2529    );
2530  }
2531      
2532// ----------------------------------------------------------------------------
2533// Filter/ImplAttributeIsNotStruct
2534// ----------------------------------------------------------------------------
2535  public void forAllUserNumber1 (
2536    short operator,
2537    java.util.Collection   values
2538  ) {
2539    refAddValue(
2540      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2541      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2542      operator,
2543      values
2544    );
2545  }
2546
2547  public void thereExistsUserNumber1 (
2548    short operator,
2549    java.util.Collection   values
2550  ) {
2551    refAddValue(
2552      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2553      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2554      operator,
2555      values
2556    );
2557  }
2558
2559  public void forAllUserNumber1 (
2560    short operator,
2561    java.math.BigDecimal  [] filterValues
2562  ) {
2563    java.util.List   arrayAsList = new java.util.ArrayList  ();
2564    for(int i = 0; i < filterValues.length; i++) {
2565      arrayAsList.add(
2566        filterValues[i]
2567      );
2568    }
2569    forAllUserNumber1 (
2570      operator,
2571      arrayAsList
2572    );
2573  }
2574
2575  public void thereExistsUserNumber1 (
2576    short operator,
2577    java.math.BigDecimal  [] filterValues
2578  ) {
2579    java.util.List   arrayAsList = new java.util.ArrayList  ();
2580    for(int i = 0; i < filterValues.length; i++) {
2581      arrayAsList.add(
2582        filterValues[i]
2583      );
2584    }
2585    thereExistsUserNumber1 (
2586      operator,
2587      arrayAsList
2588    );
2589  }
2590
2591  public void orderByUserNumber1 (
2592    short order
2593  ) {
2594    refAddValue(
2595      "org:opencrx:kernel:generic:CrxObject:userNumber1",
2596      order
2597    );
2598  }
2599      
2600// ----------------------------------------------------------------------------
2601// Filter/ImplAttributeIsNotStruct
2602// ----------------------------------------------------------------------------
2603  public void forAllUserNumber2 (
2604    short operator,
2605    java.util.Collection   values
2606  ) {
2607    refAddValue(
2608      "org:opencrx:kernel:generic:CrxObject:userNumber2",
2609      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2610      operator,
2611      values
2612    );
2613  }
2614
2615  public void thereExistsUserNumber2 (
2616    short operator,
2617    java.util.Collection   values
2618  ) {
2619    refAddValue(
2620      "org:opencrx:kernel:generic:CrxObject:userNumber2",
2621      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2622      operator,
2623      values
2624    );
2625  }
2626
2627  public void forAllUserNumber2 (
2628    short operator,
2629    java.math.BigDecimal  [] filterValues
2630  ) {
2631    java.util.List   arrayAsList = new java.util.ArrayList  ();
2632    for(int i = 0; i < filterValues.length; i++) {
2633      arrayAsList.add(
2634        filterValues[i]
2635      );
2636    }
2637    forAllUserNumber2 (
2638      operator,
2639      arrayAsList
2640    );
2641  }
2642
2643  public void thereExistsUserNumber2 (
2644    short operator,
2645    java.math.BigDecimal  [] filterValues
2646  ) {
2647    java.util.List   arrayAsList = new java.util.ArrayList  ();
2648    for(int i = 0; i < filterValues.length; i++) {
2649      arrayAsList.add(
2650        filterValues[i]
2651      );
2652    }
2653    thereExistsUserNumber2 (
2654      operator,
2655      arrayAsList
2656    );
2657  }
2658
2659  public void orderByUserNumber2 (
2660    short order
2661  ) {
2662    refAddValue(
2663      "org:opencrx:kernel:generic:CrxObject:userNumber2",
2664      order
2665    );
2666  }
2667      
2668// ----------------------------------------------------------------------------
2669// Filter/ImplAttributeIsNotStruct
2670// ----------------------------------------------------------------------------
2671  public void forAllUserNumber3 (
2672    short operator,
2673    java.util.Collection   values
2674  ) {
2675    refAddValue(
2676      "org:opencrx:kernel:generic:CrxObject:userNumber3",
2677      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2678      operator,
2679      values
2680    );
2681  }
2682
2683  public void thereExistsUserNumber3 (
2684    short operator,
2685    java.util.Collection   values
2686  ) {
2687    refAddValue(
2688      "org:opencrx:kernel:generic:CrxObject:userNumber3",
2689      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2690      operator,
2691      values
2692    );
2693  }
2694
2695  public void forAllUserNumber3 (
2696    short operator,
2697    java.math.BigDecimal  [] filterValues
2698  ) {
2699    java.util.List   arrayAsList = new java.util.ArrayList  ();
2700    for(int i = 0; i < filterValues.length; i++) {
2701      arrayAsList.add(
2702        filterValues[i]
2703      );
2704    }
2705    forAllUserNumber3 (
2706      operator,
2707      arrayAsList
2708    );
2709  }
2710
2711  public void thereExistsUserNumber3 (
2712    short operator,
2713    java.math.BigDecimal  [] filterValues
2714  ) {
2715    java.util.List   arrayAsList = new java.util.ArrayList  ();
2716    for(int i = 0; i < filterValues.length; i++) {
2717      arrayAsList.add(
2718        filterValues[i]
2719      );
2720    }
2721    thereExistsUserNumber3 (
2722      operator,
2723      arrayAsList
2724    );
2725  }
2726
2727  public void orderByUserNumber3 (
2728    short order
2729  ) {
2730    refAddValue(
2731      "org:opencrx:kernel:generic:CrxObject:userNumber3",
2732      order
2733    );
2734  }
2735      
2736// ----------------------------------------------------------------------------
2737// Filter/ImplAttributeIsNotStruct
2738// ----------------------------------------------------------------------------
2739  public void forAllUserNumber4 (
2740    short operator,
2741    java.util.Collection   values
2742  ) {
2743    refAddValue(
2744      "org:opencrx:kernel:generic:CrxObject:userNumber4",
2745      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2746      operator,
2747      values
2748    );
2749  }
2750
2751  public void thereExistsUserNumber4 (
2752    short operator,
2753    java.util.Collection   values
2754  ) {
2755    refAddValue(
2756      "org:opencrx:kernel:generic:CrxObject:userNumber4",
2757      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2758      operator,
2759      values
2760    );
2761  }
2762
2763  public void forAllUserNumber4 (
2764    short operator,
2765    java.math.BigDecimal  [] filterValues
2766  ) {
2767    java.util.List   arrayAsList = new java.util.ArrayList  ();
2768    for(int i = 0; i < filterValues.length; i++) {
2769      arrayAsList.add(
2770        filterValues[i]
2771      );
2772    }
2773    forAllUserNumber4 (
2774      operator,
2775      arrayAsList
2776    );
2777  }
2778
2779  public void thereExistsUserNumber4 (
2780    short operator,
2781    java.math.BigDecimal  [] filterValues
2782  ) {
2783    java.util.List   arrayAsList = new java.util.ArrayList  ();
2784    for(int i = 0; i < filterValues.length; i++) {
2785      arrayAsList.add(
2786        filterValues[i]
2787      );
2788    }
2789    thereExistsUserNumber4 (
2790      operator,
2791      arrayAsList
2792    );
2793  }
2794
2795  public void orderByUserNumber4 (
2796    short order
2797  ) {
2798    refAddValue(
2799      "org:opencrx:kernel:generic:CrxObject:userNumber4",
2800      order
2801    );
2802  }
2803      
2804// ----------------------------------------------------------------------------
2805// Filter/ImplAttributeIsNotStruct
2806// ----------------------------------------------------------------------------
2807  public void forAllUserString0 (
2808    short operator,
2809    java.util.Collection   values
2810  ) {
2811    refAddValue(
2812      "org:opencrx:kernel:generic:CrxObject:userString0",
2813      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2814      operator,
2815      values
2816    );
2817  }
2818
2819  public void thereExistsUserString0 (
2820    short operator,
2821    java.util.Collection   values
2822  ) {
2823    refAddValue(
2824      "org:opencrx:kernel:generic:CrxObject:userString0",
2825      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2826      operator,
2827      values
2828    );
2829  }
2830
2831  public void forAllUserString0 (
2832    short operator,
2833    String  [] filterValues
2834  ) {
2835    java.util.List   arrayAsList = new java.util.ArrayList  ();
2836    for(int i = 0; i < filterValues.length; i++) {
2837      arrayAsList.add(
2838        filterValues[i]
2839      );
2840    }
2841    forAllUserString0 (
2842      operator,
2843      arrayAsList
2844    );
2845  }
2846
2847  public void thereExistsUserString0 (
2848    short operator,
2849    String  [] filterValues
2850  ) {
2851    java.util.List   arrayAsList = new java.util.ArrayList  ();
2852    for(int i = 0; i < filterValues.length; i++) {
2853      arrayAsList.add(
2854        filterValues[i]
2855      );
2856    }
2857    thereExistsUserString0 (
2858      operator,
2859      arrayAsList
2860    );
2861  }
2862
2863  public void orderByUserString0 (
2864    short order
2865  ) {
2866    refAddValue(
2867      "org:opencrx:kernel:generic:CrxObject:userString0",
2868      order
2869    );
2870  }
2871      
2872// ----------------------------------------------------------------------------
2873// Filter/ImplAttributeIsNotStruct
2874// ----------------------------------------------------------------------------
2875  public void forAllUserString1 (
2876    short operator,
2877    java.util.Collection   values
2878  ) {
2879    refAddValue(
2880      "org:opencrx:kernel:generic:CrxObject:userString1",
2881      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2882      operator,
2883      values
2884    );
2885  }
2886
2887  public void thereExistsUserString1 (
2888    short operator,
2889    java.util.Collection   values
2890  ) {
2891    refAddValue(
2892      "org:opencrx:kernel:generic:CrxObject:userString1",
2893      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2894      operator,
2895      values
2896    );
2897  }
2898
2899  public void forAllUserString1 (
2900    short operator,
2901    String  [] filterValues
2902  ) {
2903    java.util.List   arrayAsList = new java.util.ArrayList  ();
2904    for(int i = 0; i < filterValues.length; i++) {
2905      arrayAsList.add(
2906        filterValues[i]
2907      );
2908    }
2909    forAllUserString1 (
2910      operator,
2911      arrayAsList
2912    );
2913  }
2914
2915  public void thereExistsUserString1 (
2916    short operator,
2917    String  [] filterValues
2918  ) {
2919    java.util.List   arrayAsList = new java.util.ArrayList  ();
2920    for(int i = 0; i < filterValues.length; i++) {
2921      arrayAsList.add(
2922        filterValues[i]
2923      );
2924    }
2925    thereExistsUserString1 (
2926      operator,
2927      arrayAsList
2928    );
2929  }
2930
2931  public void orderByUserString1 (
2932    short order
2933  ) {
2934    refAddValue(
2935      "org:opencrx:kernel:generic:CrxObject:userString1",
2936      order
2937    );
2938  }
2939      
2940// ----------------------------------------------------------------------------
2941// Filter/ImplAttributeIsNotStruct
2942// ----------------------------------------------------------------------------
2943  public void forAllUserString2 (
2944    short operator,
2945    java.util.Collection   values
2946  ) {
2947    refAddValue(
2948      "org:opencrx:kernel:generic:CrxObject:userString2",
2949      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
2950      operator,
2951      values
2952    );
2953  }
2954
2955  public void thereExistsUserString2 (
2956    short operator,
2957    java.util.Collection   values
2958  ) {
2959    refAddValue(
2960      "org:opencrx:kernel:generic:CrxObject:userString2",
2961      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
2962      operator,
2963      values
2964    );
2965  }
2966
2967  public void forAllUserString2 (
2968    short operator,
2969    String  [] filterValues
2970  ) {
2971    java.util.List   arrayAsList = new java.util.ArrayList  ();
2972    for(int i = 0; i < filterValues.length; i++) {
2973      arrayAsList.add(
2974        filterValues[i]
2975      );
2976    }
2977    forAllUserString2 (
2978      operator,
2979      arrayAsList
2980    );
2981  }
2982
2983  public void thereExistsUserString2 (
2984    short operator,
2985    String  [] filterValues
2986  ) {
2987    java.util.List   arrayAsList = new java.util.ArrayList  ();
2988    for(int i = 0; i < filterValues.length; i++) {
2989      arrayAsList.add(
2990        filterValues[i]
2991      );
2992    }
2993    thereExistsUserString2 (
2994      operator,
2995      arrayAsList
2996    );
2997  }
2998
2999  public void orderByUserString2 (
3000    short order
3001  ) {
3002    refAddValue(
3003      "org:opencrx:kernel:generic:CrxObject:userString2",
3004      order
3005    );
3006  }
3007      
3008// ----------------------------------------------------------------------------
3009// Filter/ImplAttributeIsNotStruct
3010// ----------------------------------------------------------------------------
3011  public void forAllUserString3 (
3012    short operator,
3013    java.util.Collection   values
3014  ) {
3015    refAddValue(
3016      "org:opencrx:kernel:generic:CrxObject:userString3",
3017      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3018      operator,
3019      values
3020    );
3021  }
3022
3023  public void thereExistsUserString3 (
3024    short operator,
3025    java.util.Collection   values
3026  ) {
3027    refAddValue(
3028      "org:opencrx:kernel:generic:CrxObject:userString3",
3029      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3030      operator,
3031      values
3032    );
3033  }
3034
3035  public void forAllUserString3 (
3036    short operator,
3037    String  [] filterValues
3038  ) {
3039    java.util.List   arrayAsList = new java.util.ArrayList  ();
3040    for(int i = 0; i < filterValues.length; i++) {
3041      arrayAsList.add(
3042        filterValues[i]
3043      );
3044    }
3045    forAllUserString3 (
3046      operator,
3047      arrayAsList
3048    );
3049  }
3050
3051  public void thereExistsUserString3 (
3052    short operator,
3053    String  [] filterValues
3054  ) {
3055    java.util.List   arrayAsList = new java.util.ArrayList  ();
3056    for(int i = 0; i < filterValues.length; i++) {
3057      arrayAsList.add(
3058        filterValues[i]
3059      );
3060    }
3061    thereExistsUserString3 (
3062      operator,
3063      arrayAsList
3064    );
3065  }
3066
3067  public void orderByUserString3 (
3068    short order
3069  ) {
3070    refAddValue(
3071      "org:opencrx:kernel:generic:CrxObject:userString3",
3072      order
3073    );
3074  }
3075      
3076// ----------------------------------------------------------------------------
3077// Filter/ImplAttributeIsNotStruct
3078// ----------------------------------------------------------------------------
3079  public void forAllUserString4 (
3080    short operator,
3081    java.util.Collection   values
3082  ) {
3083    refAddValue(
3084      "org:opencrx:kernel:generic:CrxObject:userString4",
3085      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3086      operator,
3087      values
3088    );
3089  }
3090
3091  public void thereExistsUserString4 (
3092    short operator,
3093    java.util.Collection   values
3094  ) {
3095    refAddValue(
3096      "org:opencrx:kernel:generic:CrxObject:userString4",
3097      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3098      operator,
3099      values
3100    );
3101  }
3102
3103  public void forAllUserString4 (
3104    short operator,
3105    String  [] filterValues
3106  ) {
3107    java.util.List   arrayAsList = new java.util.ArrayList  ();
3108    for(int i = 0; i < filterValues.length; i++) {
3109      arrayAsList.add(
3110        filterValues[i]
3111      );
3112    }
3113    forAllUserString4 (
3114      operator,
3115      arrayAsList
3116    );
3117  }
3118
3119  public void thereExistsUserString4 (
3120    short operator,
3121    String  [] filterValues
3122  ) {
3123    java.util.List   arrayAsList = new java.util.ArrayList  ();
3124    for(int i = 0; i < filterValues.length; i++) {
3125      arrayAsList.add(
3126        filterValues[i]
3127      );
3128    }
3129    thereExistsUserString4 (
3130      operator,
3131      arrayAsList
3132    );
3133  }
3134
3135  public void orderByUserString4 (
3136    short order
3137  ) {
3138    refAddValue(
3139      "org:opencrx:kernel:generic:CrxObject:userString4",
3140      order
3141    );
3142  }
3143      
3144// ----------------------------------------------------------------------------
3145// Filter/ImplAttributeIsNotStruct
3146// ----------------------------------------------------------------------------
3147  public void forAllCreatedAt (
3148    short operator,
3149    java.util.Collection   values
3150  ) {
3151    refAddValue(
3152      "org:openmdx:base:BasicObject:createdAt",
3153      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3154      operator,
3155      values
3156    );
3157  }
3158
3159  public void thereExistsCreatedAt (
3160    short operator,
3161    java.util.Collection   values
3162  ) {
3163    refAddValue(
3164      "org:openmdx:base:BasicObject:createdAt",
3165      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3166      operator,
3167      values
3168    );
3169  }
3170
3171  public void forAllCreatedAt (
3172    short operator,
3173    java.util.Date  [] filterValues
3174  ) {
3175    java.util.List   arrayAsList = new java.util.ArrayList  ();
3176    for(int i = 0; i < filterValues.length; i++) {
3177      arrayAsList.add(
3178        filterValues[i]
3179      );
3180    }
3181    forAllCreatedAt (
3182      operator,
3183      arrayAsList
3184    );
3185  }
3186
3187  public void thereExistsCreatedAt (
3188    short operator,
3189    java.util.Date  [] filterValues
3190  ) {
3191    java.util.List   arrayAsList = new java.util.ArrayList  ();
3192    for(int i = 0; i < filterValues.length; i++) {
3193      arrayAsList.add(
3194        filterValues[i]
3195      );
3196    }
3197    thereExistsCreatedAt (
3198      operator,
3199      arrayAsList
3200    );
3201  }
3202
3203  public void orderByCreatedAt (
3204    short order
3205  ) {
3206    refAddValue(
3207      "org:openmdx:base:BasicObject:createdAt",
3208      order
3209    );
3210  }
3211      
3212// ----------------------------------------------------------------------------
3213// Filter/ImplAttributeIsNotStruct
3214// ----------------------------------------------------------------------------
3215  public void forAllCreatedBy (
3216    short operator,
3217    java.util.Collection   values
3218  ) {
3219    refAddValue(
3220      "org:openmdx:base:BasicObject:createdBy",
3221      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3222      operator,
3223      values
3224    );
3225  }
3226
3227  public void thereExistsCreatedBy (
3228    short operator,
3229    java.util.Collection   values
3230  ) {
3231    refAddValue(
3232      "org:openmdx:base:BasicObject:createdBy",
3233      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3234      operator,
3235      values
3236    );
3237  }
3238
3239  public void forAllCreatedBy (
3240    short operator,
3241    String  [] filterValues
3242  ) {
3243    java.util.List   arrayAsList = new java.util.ArrayList  ();
3244    for(int i = 0; i < filterValues.length; i++) {
3245      arrayAsList.add(
3246        filterValues[i]
3247      );
3248    }
3249    forAllCreatedBy (
3250      operator,
3251      arrayAsList
3252    );
3253  }
3254
3255  public void thereExistsCreatedBy (
3256    short operator,
3257    String  [] filterValues
3258  ) {
3259    java.util.List   arrayAsList = new java.util.ArrayList  ();
3260    for(int i = 0; i < filterValues.length; i++) {
3261      arrayAsList.add(
3262        filterValues[i]
3263      );
3264    }
3265    thereExistsCreatedBy (
3266      operator,
3267      arrayAsList
3268    );
3269  }
3270
3271  public void orderByCreatedBy (
3272    short order
3273  ) {
3274    refAddValue(
3275      "org:openmdx:base:BasicObject:createdBy",
3276      order
3277    );
3278  }
3279      
3280// ----------------------------------------------------------------------------
3281// Filter/ImplAttributeIsNotStruct
3282// ----------------------------------------------------------------------------
3283  public void forAllModifiedAt (
3284    short operator,
3285    java.util.Collection   values
3286  ) {
3287    refAddValue(
3288      "org:openmdx:base:BasicObject:modifiedAt",
3289      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3290      operator,
3291      values
3292    );
3293  }
3294
3295  public void thereExistsModifiedAt (
3296    short operator,
3297    java.util.Collection   values
3298  ) {
3299    refAddValue(
3300      "org:openmdx:base:BasicObject:modifiedAt",
3301      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3302      operator,
3303      values
3304    );
3305  }
3306
3307  public void forAllModifiedAt (
3308    short operator,
3309    java.util.Date  [] filterValues
3310  ) {
3311    java.util.List   arrayAsList = new java.util.ArrayList  ();
3312    for(int i = 0; i < filterValues.length; i++) {
3313      arrayAsList.add(
3314        filterValues[i]
3315      );
3316    }
3317    forAllModifiedAt (
3318      operator,
3319      arrayAsList
3320    );
3321  }
3322
3323  public void thereExistsModifiedAt (
3324    short operator,
3325    java.util.Date  [] filterValues
3326  ) {
3327    java.util.List   arrayAsList = new java.util.ArrayList  ();
3328    for(int i = 0; i < filterValues.length; i++) {
3329      arrayAsList.add(
3330        filterValues[i]
3331      );
3332    }
3333    thereExistsModifiedAt (
3334      operator,
3335      arrayAsList
3336    );
3337  }
3338
3339  public void orderByModifiedAt (
3340    short order
3341  ) {
3342    refAddValue(
3343      "org:openmdx:base:BasicObject:modifiedAt",
3344      order
3345    );
3346  }
3347      
3348// ----------------------------------------------------------------------------
3349// Filter/ImplAttributeIsNotStruct
3350// ----------------------------------------------------------------------------
3351  public void forAllModifiedBy (
3352    short operator,
3353    java.util.Collection   values
3354  ) {
3355    refAddValue(
3356      "org:openmdx:base:BasicObject:modifiedBy",
3357      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3358      operator,
3359      values
3360    );
3361  }
3362
3363  public void thereExistsModifiedBy (
3364    short operator,
3365    java.util.Collection   values
3366  ) {
3367    refAddValue(
3368      "org:openmdx:base:BasicObject:modifiedBy",
3369      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3370      operator,
3371      values
3372    );
3373  }
3374
3375  public void forAllModifiedBy (
3376    short operator,
3377    String  [] filterValues
3378  ) {
3379    java.util.List   arrayAsList = new java.util.ArrayList  ();
3380    for(int i = 0; i < filterValues.length; i++) {
3381      arrayAsList.add(
3382        filterValues[i]
3383      );
3384    }
3385    forAllModifiedBy (
3386      operator,
3387      arrayAsList
3388    );
3389  }
3390
3391  public void thereExistsModifiedBy (
3392    short operator,
3393    String  [] filterValues
3394  ) {
3395    java.util.List   arrayAsList = new java.util.ArrayList  ();
3396    for(int i = 0; i < filterValues.length; i++) {
3397      arrayAsList.add(
3398        filterValues[i]
3399      );
3400    }
3401    thereExistsModifiedBy (
3402      operator,
3403      arrayAsList
3404    );
3405  }
3406
3407  public void orderByModifiedBy (
3408    short order
3409  ) {
3410    refAddValue(
3411      "org:openmdx:base:BasicObject:modifiedBy",
3412      order
3413    );
3414  }
3415      
3416// ----------------------------------------------------------------------------
3417// Filter/ImplReference
3418// ----------------------------------------------------------------------------
3419  public void forAllContext (
3420    short operator,
3421    org.openmdx.base.cci.Context[] filterValues
3422  ) {
3423    java.util.List   arrayAsList = new java.util.ArrayList  ();
3424    for(int i = 0; i < filterValues.length; i++) {
3425      arrayAsList.add(
3426        filterValues[i]
3427      );
3428    }
3429    forAllContext (
3430      operator,
3431      arrayAsList
3432    );
3433  }
3434
3435  public void thereExistsContext (
3436    short operator,
3437    org.openmdx.base.cci.Context[] filterValues
3438  ) {
3439    java.util.List   arrayAsList = new java.util.ArrayList  ();
3440    for(int i = 0; i < filterValues.length; i++) {
3441      arrayAsList.add(
3442        filterValues[i]
3443      );
3444    }
3445    thereExistsContext (
3446      operator,
3447      arrayAsList
3448    );
3449  }
3450
3451  public void forAllContext (
3452    short operator,
3453    java.util.Collection   values
3454  ) {
3455    refAddValue(
3456      "org:openmdx:base:ContextCapable:context",
3457      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3458      operator,
3459      values
3460    );
3461  }
3462
3463  public void thereExistsContext (
3464    short operator,
3465    java.util.Collection   values
3466  ) {
3467    refAddValue(
3468      "org:openmdx:base:ContextCapable:context",
3469      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3470      operator,
3471      values
3472    );
3473  }
3474      
3475// ----------------------------------------------------------------------------
3476// Filter/ImplAttributeIsNotStruct
3477// ----------------------------------------------------------------------------
3478  public void forAllIdentity (
3479    short operator,
3480    java.util.Collection   values
3481  ) {
3482    refAddValue(
3483      "org:openmdx:base:ExtentCapable:identity",
3484      org.openmdx.compatibility.base.query.Quantors.FOR_ALL,
3485      operator,
3486      values
3487    );
3488  }
3489
3490  public void thereExistsIdentity (
3491    short operator,
3492    java.util.Collection   values
3493  ) {
3494    refAddValue(
3495      "org:openmdx:base:ExtentCapable:identity",
3496      org.openmdx.compatibility.base.query.Quantors.THERE_EXISTS,
3497      operator,
3498      values
3499    );
3500  }
3501
3502  public void forAllIdentity (
3503    short operator,
3504    String  [] filterValues
3505  ) {
3506    java.util.List   arrayAsList = new java.util.ArrayList  ();
3507    for(int i = 0; i < filterValues.length; i++) {
3508      arrayAsList.add(
3509        filterValues[i]
3510      );
3511    }
3512    forAllIdentity (
3513      operator,
3514      arrayAsList
3515    );
3516  }
3517
3518  public void thereExistsIdentity (
3519    short operator,
3520    String  [] filterValues
3521  ) {
3522    java.util.List   arrayAsList = new java.util.ArrayList  ();
3523    for(int i = 0; i < filterValues.length; i++) {
3524      arrayAsList.add(
3525        filterValues[i]
3526      );
3527    }
3528    thereExistsIdentity (
3529      operator,
3530      arrayAsList
3531    );
3532  }
3533
3534  public void orderByIdentity (
3535    short order
3536  ) {
3537    refAddValue(
3538      "org:openmdx:base:ExtentCapable:identity",
3539      order
3540    );
3541  }
3542      
3543// ----------------------------------------------------------------------------
3544// Filter/ImplEnd
3545// ----------------------------------------------------------------------------
3546}        
3547
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags