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::toMof(Array<Sint8>& out) const
167 {
168 _checkRep();
169 _rep->toMof(out);
170 }
171
172 void CIMQualifier::printMof(PEGASUS_STD(ostream)& o) const
173 {
174 _checkRep();
175 _rep->printMof(o);
176 }
177
|
178 mike 1.9 Boolean CIMQualifier::identical(const CIMConstQualifier& x) const
179 {
180 x._checkRep();
181 _checkRep();
182 return _rep->identical(x._rep);
|
183 kumpf 1.10 }
184
185 CIMQualifier CIMQualifier::clone() const
186 {
187 return CIMQualifier(_rep->clone());
188 }
189
190 void CIMQualifier::_checkRep() const
191 {
192 if (!_rep)
|
193 kumpf 1.11 ThrowUninitializedHandle();
|
194 kumpf 1.10 }
195
196
197 ////////////////////////////////////////////////////////////////////////////////
198 //
199 // CIMConstQualifier
200 //
201 ////////////////////////////////////////////////////////////////////////////////
202
203 CIMConstQualifier::CIMConstQualifier()
204 : _rep(0)
205 {
206 }
207
208 CIMConstQualifier::CIMConstQualifier(const CIMConstQualifier& x)
209 {
210 Inc(_rep = x._rep);
211 }
212
213 CIMConstQualifier::CIMConstQualifier(const CIMQualifier& x)
214 {
215 kumpf 1.10 Inc(_rep = x._rep);
216 }
217
218 CIMConstQualifier::CIMConstQualifier(
219 const String& name,
220 const CIMValue& value,
221 Uint32 flavor,
222 Boolean propagated)
223 {
224 _rep = new CIMQualifierRep(name, value, flavor, propagated);
225 }
226
227 CIMConstQualifier::~CIMConstQualifier()
228 {
229 Dec(_rep);
230 }
231
232 CIMConstQualifier& CIMConstQualifier::operator=(const CIMConstQualifier& x)
233 {
234 if (x._rep != _rep)
235 {
236 kumpf 1.10 Dec(_rep);
237 Inc(_rep = x._rep);
238 }
239
240 return *this;
241 }
242
243 CIMConstQualifier& CIMConstQualifier::operator=(const CIMQualifier& x)
244 {
245 if (x._rep != _rep)
246 {
247 Dec(_rep);
248 Inc(_rep = x._rep);
249 }
250
251 return *this;
252 }
253
254 const String& CIMConstQualifier::getName() const
255 {
256 _checkRep();
257 kumpf 1.10 return _rep->getName();
258 }
259
260 CIMType CIMConstQualifier::getType() const
261 {
262 _checkRep();
263 return _rep->getType();
264 }
265
266 Boolean CIMConstQualifier::isArray() const
267 {
268 _checkRep();
269 return _rep->isArray();
270 }
271
272 const CIMValue& CIMConstQualifier::getValue() const
273 {
274 _checkRep();
275 return _rep->getValue();
276 }
277
278 kumpf 1.10 const Uint32 CIMConstQualifier::getFlavor() const
279 {
280 _checkRep();
281 return _rep->getFlavor();
282 }
283
284 Boolean CIMConstQualifier::isFlavor(Uint32 flavor) const
285 {
286 return ((getFlavor() & flavor) !=0);
287 }
288
289 Boolean CIMConstQualifier::isFlavorToSubclass() const
290 {
291 return ((getFlavor() & CIMFlavor::TOSUBCLASS) != 0);
292 }
293
294 Boolean CIMConstQualifier::isFlavorToInstance() const
295 {
296 return ((getFlavor() & CIMFlavor::TOINSTANCE) != 0);
297 }
298
299 kumpf 1.10 Boolean CIMConstQualifier::isFlavorOverridable() const
300 {
301 return ((getFlavor() & CIMFlavor::OVERRIDABLE) != 0);
302 }
303
304 const Uint32 CIMConstQualifier::getPropagated() const
305 {
306 _checkRep();
307 return _rep->getPropagated();
308 }
309
|
310 kumpf 1.12 Boolean CIMConstQualifier::isNull() const
|
311 kumpf 1.10 {
|
312 kumpf 1.12 return (_rep == 0)? true : false;
|
313 kumpf 1.10 }
314
315 Boolean CIMConstQualifier::identical(const CIMConstQualifier& x) const
316 {
317 x._checkRep();
318 _checkRep();
319 return _rep->identical(x._rep);
320 }
321
322 CIMQualifier CIMConstQualifier::clone() const
323 {
324 return CIMQualifier(_rep->clone());
325 }
326
327 void CIMConstQualifier::_checkRep() const
328 {
329 if (!_rep)
|
330 kumpf 1.11 ThrowUninitializedHandle();
|
331 mike 1.9 }
332
333 PEGASUS_NAMESPACE_END
|
Return to
CIMQualifier.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common