1 marek 1.1 // Copyright (c) 2007 DMTF.  All rights reserved.
  2           //===============
  3           //Meta Qualifiers
  4           //===============
  5           
  6           Qualifier Association : boolean = false, 
  7               Scope(association), 
  8               Flavor(DisableOverride, ToSubclass);
  9           
 10           Qualifier Indication : boolean = false, 
 11               Scope(class, indication), 
 12               Flavor(DisableOverride, ToSubclass);
 13           
 14           //===================
 15           //Standard Qualifiers
 16           //===================
 17           
 18           Qualifier Abstract : boolean = false, 
 19               Scope(class, association, indication), 
 20               Flavor(EnableOverride, Restricted);
 21           
 22 marek 1.1 Qualifier Aggregate : boolean = false, 
 23               Scope(reference), 
 24               Flavor(DisableOverride, ToSubclass);
 25           
 26           Qualifier Aggregation : boolean = false, 
 27               Scope(association), 
 28               Flavor(DisableOverride, ToSubclass);
 29           
 30           Qualifier ArrayType : string = "Bag", 
 31               Scope(property, parameter), 
 32               Flavor(DisableOverride, ToSubclass);
 33           
 34           Qualifier BitMap : string[], 
 35               Scope(property, method, parameter);
 36           
 37           Qualifier BitValues : string[], 
 38               Scope(property, method, parameter), 
 39               Flavor(EnableOverride, ToSubclass, Translatable);
 40           
 41           Qualifier ClassConstraint : string[], 
 42               Scope(class, association, indication);
 43 marek 1.1 
 44           Qualifier Composition : boolean = false, 
 45               Scope(association), 
 46               Flavor(DisableOverride, ToSubclass);
 47           
 48           Qualifier Correlatable : string[], 
 49               Scope(property);
 50           
 51           Qualifier Counter : boolean = false, 
 52               Scope(property, method, parameter);
 53           
 54           Qualifier Deprecated : string[], 
 55               Scope(any), 
 56               Flavor(EnableOverride, Restricted);
 57           
 58           Qualifier Description : string = null, 
 59               Scope(any), 
 60               Flavor(EnableOverride, ToSubclass, Translatable);
 61           
 62           Qualifier DisplayName : string = null, 
 63               Scope(any), 
 64 marek 1.1     Flavor(EnableOverride, ToSubclass, Translatable);
 65           
 66           Qualifier DN : boolean = false, 
 67               Scope(property, method, parameter), 
 68               Flavor(DisableOverride, ToSubclass);
 69           
 70           Qualifier EmbeddedInstance : string = null, 
 71               Scope(property, method, parameter);
 72           
 73           Qualifier EmbeddedObject : boolean = false, 
 74               Scope(property, method, parameter), 
 75               Flavor(DisableOverride, ToSubclass);
 76           
 77           Qualifier Exception : boolean = false, 
 78               Scope(class, indication), 
 79               Flavor(DisableOverride, ToSubclass);
 80           
 81           Qualifier Experimental : boolean = false, 
 82               Scope(any), 
 83               Flavor(EnableOverride, Restricted);
 84           
 85 marek 1.1 Qualifier Gauge : boolean = false, 
 86               Scope(property, method, parameter);
 87           
 88           Qualifier In : boolean = true, 
 89               Scope(parameter), 
 90               Flavor(DisableOverride, ToSubclass);
 91           
 92           Qualifier IsPUnit : boolean = false, 
 93               Scope(property, method, parameter);
 94           
 95           Qualifier Key : boolean = false, 
 96               Scope(property, reference), 
 97               Flavor(DisableOverride, ToSubclass);
 98           
 99           Qualifier MappingStrings : string[], 
100               Scope(any);
101           
102           Qualifier Max : uint32 = null, 
103               Scope(reference);
104           
105           Qualifier MaxLen : uint32 = null, 
106 marek 1.1     Scope(property, method, parameter);
107           
108           Qualifier MaxValue : sint64 = null, 
109               Scope(property, method, parameter);
110           
111           Qualifier MethodConstraint : string[], 
112               Scope(method);
113           
114           Qualifier Min : uint32 = 0, 
115               Scope(reference);
116           
117           Qualifier MinLen : uint32 = 0, 
118               Scope(property, method, parameter);
119           
120           Qualifier MinValue : sint64 = null, 
121               Scope(property, method, parameter);
122           
123           Qualifier ModelCorrespondence : string[], 
124               Scope(any);
125           
126           /*
127 marek 1.1 The Nonlocal qualifer has been removed (as an errata) as of CIM 2.3
128           For more information see CR1461.
129           */
130           Qualifier Nonlocal : string = null, 
131               Scope(reference);
132           
133           /*
134           The NonlocalType qualifer has been removed (as an errata) as of CIM 2.3
135           For more information see CR1461.
136           */
137           Qualifier NonlocalType : string = null, 
138               Scope(reference);
139           
140           Qualifier NullValue : string = null, 
141               Scope(property), 
142               Flavor(DisableOverride, ToSubclass);
143           
144           Qualifier Octetstring : boolean = false, 
145               Scope(property, method, parameter), 
146               Flavor(DisableOverride, ToSubclass);
147           
148 marek 1.1 Qualifier Out : boolean = false, 
149               Scope(parameter), 
150               Flavor(DisableOverride, ToSubclass);
151           
152           Qualifier Override : string = null, 
153               Scope(property, reference, method), 
154               Flavor(EnableOverride, Restricted);
155           
156           Qualifier Propagated : string = null, 
157               Scope(property), 
158               Flavor(DisableOverride, ToSubclass);
159           
160           Qualifier PropertyConstraint : string[], 
161               Scope(property, reference);
162           
163           Qualifier PUnit : string = null, 
164               Scope(property, method, parameter);
165           
166           Qualifier Read : boolean = true, 
167               Scope(property);
168           
169 marek 1.1 Qualifier Required : boolean = false, 
170               Scope(property, reference, method, parameter), 
171               Flavor(DisableOverride, ToSubclass);
172           
173           //  The Revision qualifier has been deprecated. For the replacement,
174           //  see the usage rule for the version qualifier in the CIM
175           //  Specification.
176           
177           Qualifier Revision : string = null, 
178               Scope(class, association, indication), 
179               Flavor(EnableOverride, ToSubclass, Translatable);
180           
181           Qualifier Schema : string = null, 
182               Scope(property, method), 
183               Flavor(DisableOverride, ToSubclass, Translatable);
184           
185           /*
186           The Source qualifer has been removed (as an errata) as of CIM 2.3
187           For more information see CR1461.
188           */
189           Qualifier Source : string = null, 
190 marek 1.1     Scope(class, association, indication);
191           
192           /*
193           The SourceType qualifer has been removed (as an errata) as of CIM 2.3
194           For more information see CR1461.
195           */
196           Qualifier SourceType : string = null, 
197               Scope(class, association, indication, reference);
198           
199           Qualifier Static : boolean = false, 
200               Scope(property, method), 
201               Flavor(DisableOverride, ToSubclass);
202           
203           Qualifier Terminal : boolean = false, 
204               Scope(class, association, indication);
205           
206           Qualifier UMLPackagePath : string = null, 
207               Scope(class, association, indication);
208           
209           Qualifier Units : string = null, 
210               Scope(property, method, parameter), 
211 marek 1.1     Flavor(EnableOverride, ToSubclass, Translatable);
212           
213           Qualifier ValueMap : string[], 
214               Scope(property, method, parameter);
215           
216           Qualifier Values : string[], 
217               Scope(property, method, parameter), 
218               Flavor(EnableOverride, ToSubclass, Translatable);
219           
220           Qualifier Version : string = null, 
221               Scope(class, association, indication), 
222               Flavor(EnableOverride, Restricted, Translatable);
223           
224           Qualifier Weak : boolean = false, 
225               Scope(reference), 
226               Flavor(DisableOverride, ToSubclass);
227           
228           Qualifier Write : boolean = false, 
229               Scope(property);
230