1 mike 1.9 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to
7 // deal in the Software without restriction, including without limitation the
8 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 // sell copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
13 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
14 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
15 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
16 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
17 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
19 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 //
21 //==============================================================================
22 mike 1.9 //
23 // Author: Mike Brasher (mbrasher@bmc.com)
24 //
|
25 kumpf 1.10 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
26 mike 1.9 //
27 //%/////////////////////////////////////////////////////////////////////////////
28
29 #include "CIMQualifier.h"
|
30 kumpf 1.10 #include "CIMQualifierRep.h"
|
31 mike 1.9
32 PEGASUS_NAMESPACE_BEGIN
33
34 #define PEGASUS_ARRAY_T CIMQualifier
35 # include "ArrayImpl.h"
36 #undef PEGASUS_ARRAY_T
37
|
38 kumpf 1.10 ////////////////////////////////////////////////////////////////////////////////
39 //
40 // CIMQualifier
41 //
42 ////////////////////////////////////////////////////////////////////////////////
43
44 CIMQualifier::CIMQualifier()
45 : _rep(0)
46 {
47 }
48
49 CIMQualifier::CIMQualifier(const CIMQualifier& x)
50 {
51 Inc(_rep = x._rep);
52 }
53
54 CIMQualifier::CIMQualifier(
55 const String& name,
56 const CIMValue& value,
57 Uint32 flavor,
58 Boolean propagated)
59 kumpf 1.10 {
60 _rep = new CIMQualifierRep(name, value, flavor, propagated);
61 }
62
63 CIMQualifier::CIMQualifier(CIMQualifierRep* rep)
64 : _rep(rep)
65 {
66 }
67
68 CIMQualifier::~CIMQualifier()
69 {
70 Dec(_rep);
71 }
72
73 CIMQualifier& CIMQualifier::operator=(const CIMQualifier& x)
74 {
75 if (x._rep != _rep)
76 {
77 Dec(_rep);
78 Inc(_rep = x._rep);
79 }
80 kumpf 1.10
81 return *this;
82 }
83
84 const String& CIMQualifier::getName() const
85 {
86 _checkRep();
87 return _rep->getName();
88 }
89
90 void CIMQualifier::setName(const String& name)
91 {
92 _checkRep();
93 _rep->setName(name);
94 }
95
96 CIMType CIMQualifier::getType() const
97 {
98 _checkRep();
99 return _rep->getType();
100 }
101 kumpf 1.10
102 Boolean CIMQualifier::isArray() const
103 {
104 _checkRep();
105 return _rep->isArray();
106 }
107
108 const CIMValue& CIMQualifier::getValue() const
109 {
110 _checkRep();
111 return _rep->getValue();
112 }
113
114 void CIMQualifier::setValue(const CIMValue& value)
115 {
116 _checkRep();
117 _rep->setValue(value);
118 }
119
120 void CIMQualifier::setFlavor(Uint32 flavor)
121 {
122 kumpf 1.10 _checkRep();
123 _rep->setFlavor(flavor);
124 }
125
126 void CIMQualifier::unsetFlavor(Uint32 flavor)
127 {
128 _checkRep();
129 _rep->unsetFlavor(flavor);
130 }
131
132 Uint32 CIMQualifier::getFlavor() const
133 {
134 _checkRep();
135 return _rep->getFlavor();
136 }
137
138 Boolean CIMQualifier::isFlavor(Uint32 flavor) const
139 {
140 return _rep->isFlavor(flavor);
141 }
142
143 kumpf 1.10 void CIMQualifier::resolveFlavor(Uint32 inheritedFlavor, Boolean inherited)
144 {
145 _checkRep();
146 _rep->resolveFlavor(inheritedFlavor, inherited);
147 }
148
149 const Uint32 CIMQualifier::getPropagated() const
150 {
151 _checkRep();
152 return _rep->getPropagated();
153 }
154
155 void CIMQualifier::setPropagated(Boolean propagated)
156 {
157 _checkRep();
158 _rep->setPropagated(propagated);
159 }
160
|
161 kumpf 1.12 Boolean CIMQualifier::isNull() const
|
162 kumpf 1.10 {
|
163 kumpf 1.12 return (_rep == 0)? true : false;
|
164 kumpf 1.10 }
165
166 void CIMQualifier::toXml(Array<Sint8>& out) const
167 {
168 _checkRep();
169 _rep->toXml(out);
170 }
171
172 void CIMQualifier::print(PEGASUS_STD(ostream)& o) const
173 {
174 _checkRep();
175 _rep->print(o);
176 }
177
178 void CIMQualifier::toMof(Array<Sint8>& out) const
179 {
180 _checkRep();
181 _rep->toMof(out);
182 }
183
184 void CIMQualifier::printMof(PEGASUS_STD(ostream)& o) const
185 kumpf 1.10 {
186 _checkRep();
187 _rep->printMof(o);
188 }
189
|
190 mike 1.9 Boolean CIMQualifier::identical(const CIMConstQualifier& x) const
191 {
192 x._checkRep();
193 _checkRep();
194 return _rep->identical(x._rep);
|
195 kumpf 1.10 }
196
197 CIMQualifier CIMQualifier::clone() const
198 {
199 return CIMQualifier(_rep->clone());
200 }
201
202 void CIMQualifier::_checkRep() const
203 {
204 if (!_rep)
|
205 kumpf 1.11 ThrowUninitializedHandle();
|
206 kumpf 1.10 }
207
208
209 ////////////////////////////////////////////////////////////////////////////////
210 //
211 // CIMConstQualifier
212 //
213 ////////////////////////////////////////////////////////////////////////////////
214
215 CIMConstQualifier::CIMConstQualifier()
216 : _rep(0)
217 {
218 }
219
220 CIMConstQualifier::CIMConstQualifier(const CIMConstQualifier& x)
221 {
222 Inc(_rep = x._rep);
223 }
224
225 CIMConstQualifier::CIMConstQualifier(const CIMQualifier& x)
226 {
227 kumpf 1.10 Inc(_rep = x._rep);
228 }
229
230 CIMConstQualifier::CIMConstQualifier(
231 const String& name,
232 const CIMValue& value,
233 Uint32 flavor,
234 Boolean propagated)
235 {
236 _rep = new CIMQualifierRep(name, value, flavor, propagated);
237 }
238
239 CIMConstQualifier::~CIMConstQualifier()
240 {
241 Dec(_rep);
242 }
243
244 CIMConstQualifier& CIMConstQualifier::operator=(const CIMConstQualifier& x)
245 {
246 if (x._rep != _rep)
247 {
248 kumpf 1.10 Dec(_rep);
249 Inc(_rep = x._rep);
250 }
251
252 return *this;
253 }
254
255 CIMConstQualifier& CIMConstQualifier::operator=(const CIMQualifier& x)
256 {
257 if (x._rep != _rep)
258 {
259 Dec(_rep);
260 Inc(_rep = x._rep);
261 }
262
263 return *this;
264 }
265
266 const String& CIMConstQualifier::getName() const
267 {
268 _checkRep();
269 kumpf 1.10 return _rep->getName();
270 }
271
272 CIMType CIMConstQualifier::getType() const
273 {
274 _checkRep();
275 return _rep->getType();
276 }
277
278 Boolean CIMConstQualifier::isArray() const
279 {
280 _checkRep();
281 return _rep->isArray();
282 }
283
284 const CIMValue& CIMConstQualifier::getValue() const
285 {
286 _checkRep();
287 return _rep->getValue();
288 }
289
290 kumpf 1.10 const Uint32 CIMConstQualifier::getFlavor() const
291 {
292 _checkRep();
293 return _rep->getFlavor();
294 }
295
296 Boolean CIMConstQualifier::isFlavor(Uint32 flavor) const
297 {
298 return ((getFlavor() & flavor) !=0);
299 }
300
301 Boolean CIMConstQualifier::isFlavorToSubclass() const
302 {
303 return ((getFlavor() & CIMFlavor::TOSUBCLASS) != 0);
304 }
305
306 Boolean CIMConstQualifier::isFlavorToInstance() const
307 {
308 return ((getFlavor() & CIMFlavor::TOINSTANCE) != 0);
309 }
310
311 kumpf 1.10 Boolean CIMConstQualifier::isFlavorOverridable() const
312 {
313 return ((getFlavor() & CIMFlavor::OVERRIDABLE) != 0);
314 }
315
316 const Uint32 CIMConstQualifier::getPropagated() const
317 {
318 _checkRep();
319 return _rep->getPropagated();
320 }
321
|
322 kumpf 1.12 Boolean CIMConstQualifier::isNull() const
|
323 kumpf 1.10 {
|
324 kumpf 1.12 return (_rep == 0)? true : false;
|
325 kumpf 1.10 }
326
327 void CIMConstQualifier::toXml(Array<Sint8>& out) const
328 {
329 _checkRep();
330 _rep->toXml(out);
331 }
332
333 void CIMConstQualifier::print(PEGASUS_STD(ostream)& o) const
334 {
335 _checkRep();
336 _rep->print(o);
337 }
338
339 Boolean CIMConstQualifier::identical(const CIMConstQualifier& x) const
340 {
341 x._checkRep();
342 _checkRep();
343 return _rep->identical(x._rep);
344 }
345
346 kumpf 1.10 CIMQualifier CIMConstQualifier::clone() const
347 {
348 return CIMQualifier(_rep->clone());
349 }
350
351 void CIMConstQualifier::_checkRep() const
352 {
353 if (!_rep)
|
354 kumpf 1.11 ThrowUninitializedHandle();
|
355 mike 1.9 }
356
357 PEGASUS_NAMESPACE_END
|
Return to
CIMQualifier.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common