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