1 mike 1.1 //BEGIN_LICENSE
2 //
3 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a
6 // copy of this software and associated documentation files (the "Software"),
7 // to deal in the Software without restriction, including without limitation
8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 // and/or sell copies of the Software, and to permit persons to whom the
10 // Software is furnished to do so, subject to the following conditions:
11 //
12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
18 // DEALINGS IN THE SOFTWARE.
19 //
20 //END_LICENSE
21 //BEGIN_HISTORY
22 mike 1.1 //
23 // Author:
24 //
25 // $Log: CIMQualifier.h,v $
26 // Revision 1.2 2001/02/18 03:56:01 mike
27 // Changed more class names (e.g., ConstClassDecl -> CIMConstClass)
28 //
29 // Revision 1.1 2001/02/16 02:07:06 mike
30 // Renamed many classes and headers (using new CIM prefixes).
31 //
32 // Revision 1.4 2001/01/30 23:39:00 karl
33 // Add doc++ Documentation to header files
34 //
35 // Revision 1.3 2001/01/23 01:25:35 mike
36 // Reworked resolve scheme.
37 //
38 // Revision 1.2 2001/01/15 04:31:44 mike
39 // worked on resolve scheme
40 //
41 // Revision 1.1.1.1 2001/01/14 19:53:06 mike
42 // Pegasus import
43 mike 1.1 //
44 //
45 //END_HISTORY
46
47 /*
48 CIMQualifier.h - Defines the CIM qualifiers class.
49 This class represents a CIM qualifiers. It is almost identical to
50 CIMQualifierDecl except that it has no scope member.
51
52 */
53
54 #ifndef Pegasus_Qualifier_h
55 #define Pegasus_Qualifier_h
56
57 #include <Pegasus/Common/Config.h>
58 #include <Pegasus/Common/CIMQualifierRep.h>
59
60 PEGASUS_NAMESPACE_BEGIN
61
62 ////////////////////////////////////////////////////////////////////////////////
63 //
64 mike 1.1 // CIMQualifier
65 //
66 ////////////////////////////////////////////////////////////////////////////////
67
68 class CIMConstQualifier;
69 class CIMClassRep;
70 /** Class CIMQualifier - This class defines the Pegasus implementation of the CIM
71 CIMQualifier \Ref{QUALIFIER}.
72 */
73 class PEGASUS_COMMON_LINKAGE CIMQualifier
74 {
75 public:
76
77 /** Constructor instantiates a CIM qualifier with empty name value
78 fields.Constructor
79 @return instantiated empty qualifier object
80 */
81 CIMQualifier() : _rep(0)
82 {
83
84 }
85 mike 1.1 /** Constructor - instantiates a CIM qualifier object from another
86 qualifier object.
87 @param CIM CIMQualifier object
88 ATTN: What is differenc from clone?
89 @return - Instantiated qualifier object
90 */
91 CIMQualifier(const CIMQualifier& x)
92 {
93 Inc(_rep = x._rep);
94 }
95 /** Constructor - Instantiates a CIM qualifier object with the parameters
96 defined on input.
97 @param String representing CIMName for the new qualifier
98 @param value
99 @param flavor - ATTN:
100 @param propoagated - ATTN:
101 @return -Returns the instantiated qualifier object or throws an exception
102 if the name argument is illegal
103
104 @exception Throws IllegalName if name argument not legal CIM
105 identifier.
106 mike 1.1 */
107 CIMQualifier(
108 const String& name,
109 const CIMValue& value,
110 Uint32 flavor = CIMFlavor::DEFAULTS,
111 Boolean propagated = false)
112 {
113 _rep = new CIMQualifierRep(name, value, flavor, propagated);
114 }
115 /// destructor
116 ~CIMQualifier()
117 {
118 Dec(_rep);
119 }
120 /// operator
121 CIMQualifier& operator=(const CIMQualifier& x)
122 {
123 if (x._rep != _rep)
124 {
125 Dec(_rep);
126 Inc(_rep = x._rep);
127 mike 1.1 }
128
129 return *this;
130 }
131
132 /** CIMMethod
133
134 */
135 const String& getName() const
136 {
137 _checkRep();
138 return _rep->getName();
139 }
140
141 /** CIMMethod
142 Throws IllegalName if name argument not legal CIM identifier.
143 */
144 void setName(const String& name)
145 {
146 _checkRep();
147 _rep->setName(name);
148 mike 1.1 }
149
150 /** CIMMethod
151
152 */
153 CIMType getType() const
154 {
155 _checkRep();
156 return _rep->getType();
157 }
158
159 /** CIMMethod
160
161 */
162 Boolean isArray() const
163 {
164 _checkRep();
165 return _rep->isArray();
166 }
167
168 /** CIMMethod
169 mike 1.1
170 */
171 const CIMValue& getValue() const
172 {
173 _checkRep();
174 return _rep->getValue();
175 }
176
177 /** CIMMethod
178
179 */
180 void setValue(const CIMValue& value)
181 {
182 _checkRep();
183 _rep->setValue(value);
184 }
185
186 /** CIMMethod
187
188 */
189 Uint32 getFlavor() const
190 mike 1.1 {
191 _checkRep();
192 return _rep->getFlavor();
193 }
194
195 /** CIMMethod
196
197 */
198 const Uint32 getPropagated() const
199 {
200 _checkRep();
201 return _rep->getPropagated();
202 }
203
204 /** CIMMethod
205
206 */
207 void setPropagated(Boolean propagated)
208 {
209 _checkRep();
210 _rep->setPropagated(propagated);
211 mike 1.1 }
212
213 /** CIMMethod
214
215 */
216 operator int() const { return _rep != 0; }
217
218 /** CIMMethod
219
220 */
221 void toXml(Array<Sint8>& out) const
222 {
223 _checkRep();
224 _rep->toXml(out);
225 }
226
227 /** CIMMethod
228
229 */
230 void print() const
231 {
232 mike 1.1 _checkRep();
233 _rep->print();
234 }
235
236 /** CIMMethod
237
238 */
239 Boolean identical(const CIMConstQualifier& x) const;
240
241 /** CIMMethod
242
243 */
244 CIMQualifier clone() const
245 {
246 return CIMQualifier(_rep->clone());
247 }
248
249 private:
250
251 CIMQualifier(CIMQualifierRep* rep) : _rep(rep)
252 {
253 mike 1.1 }
254
255 void _checkRep() const
256 {
257 if (!_rep)
258 throw UnitializedHandle();
259 }
260
261 CIMQualifierRep* _rep;
262 friend class CIMConstQualifier;
263 friend class CIMClassRep;
264 };
265
266 ////////////////////////////////////////////////////////////////////////////////
267 //
268 // CIMConstQualifier
269 //
270 ////////////////////////////////////////////////////////////////////////////////
271
272 class PEGASUS_COMMON_LINKAGE CIMConstQualifier
273 {
274 mike 1.1 public:
275
276 CIMConstQualifier() : _rep(0)
277 {
278
279 }
280
281 CIMConstQualifier(const CIMConstQualifier& x)
282 {
283 Inc(_rep = x._rep);
284 }
285
286 CIMConstQualifier(const CIMQualifier& x)
287 {
288 Inc(_rep = x._rep);
289 }
290
291 // Throws IllegalName if name argument not legal CIM identifier.
292
293 CIMConstQualifier(
294 const String& name,
295 mike 1.1 const CIMValue& value,
296 Uint32 flavor = CIMFlavor::DEFAULTS,
297 Boolean propagated = false)
298 {
299 _rep = new CIMQualifierRep(name, value, flavor, propagated);
300 }
301
302 ~CIMConstQualifier()
303 {
304 Dec(_rep);
305 }
306
307 CIMConstQualifier& operator=(const CIMConstQualifier& x)
308 {
309 if (x._rep != _rep)
310 {
311 Dec(_rep);
312 Inc(_rep = x._rep);
313 }
314
315 return *this;
316 mike 1.1 }
317
318 CIMConstQualifier& operator=(const CIMQualifier& x)
319 {
320 if (x._rep != _rep)
321 {
322 Dec(_rep);
323 Inc(_rep = x._rep);
324 }
325
326 return *this;
327 }
328
329 const String& getName() const
330 {
331 _checkRep();
332 return _rep->getName();
333 }
334
335 CIMType getType() const
336 {
337 mike 1.1 _checkRep();
338 return _rep->getType();
339 }
340
341 Boolean isArray() const
342 {
343 _checkRep();
344 return _rep->isArray();
345 }
346
347 const CIMValue& getValue() const
348 {
349 _checkRep();
350 return _rep->getValue();
351 }
352
353 const Uint32 getFlavor() const
354 {
355 _checkRep();
356 return _rep->getFlavor();
357 }
358 mike 1.1
359 const Uint32 getPropagated() const
360 {
361 _checkRep();
362 return _rep->getPropagated();
363 }
364
365 operator int() const { return _rep != 0; }
366
367 void toXml(Array<Sint8>& out) const
368 {
369 _checkRep();
370 _rep->toXml(out);
371 }
372
373 void print() const
374 {
375 _checkRep();
376 _rep->print();
377 }
378
379 mike 1.1 Boolean identical(const CIMConstQualifier& x) const
380 {
381 x._checkRep();
382 _checkRep();
383 return _rep->identical(x._rep);
384 }
385
386 CIMQualifier clone() const
387 {
388 return CIMQualifier(_rep->clone());
389 }
390
391 private:
392
393 void _checkRep() const
394 {
395 if (!_rep)
396 throw UnitializedHandle();
397 }
398
399 CIMQualifierRep* _rep;
400 mike 1.1 friend class CIMQualifier;
401 };
402
403 PEGASUS_NAMESPACE_END
404
405 #endif /* Pegasus_Qualifier_h */
|
Return to
CIMQualifier.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common