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: CIMParameter.h,v $
|
31 mike 1.1 //
32 // Revision 1.1 2001/02/16 02:07:06 mike
33 // Renamed many classes and headers (using new CIM prefixes).
34 //
35 // Revision 1.2 2001/01/15 04:31:44 mike
36 // worked on resolve scheme
37 //
38 // Revision 1.1.1.1 2001/01/14 19:53:02 mike
39 // Pegasus import
40 //
41 //
42 //END_HISTORY
43
44 #ifndef Pegasus_Parameter_h
45 #define Pegasus_Parameter_h
46
47 #include <Pegasus/Common/Config.h>
48 #include <Pegasus/Common/CIMParameterRep.h>
49
50 PEGASUS_NAMESPACE_BEGIN
51
52 mike 1.1 ////////////////////////////////////////////////////////////////////////////////
53 //
54 // CIMParameter
55 //
56 ////////////////////////////////////////////////////////////////////////////////
57
58 class CIMConstParameter;
59
60 class PEGASUS_COMMON_LINKAGE CIMParameter
61 {
62 public:
63
64 CIMParameter() : _rep(0)
65 {
66
67 }
68
69 CIMParameter(const CIMParameter& x)
70 {
71 Inc(_rep = x._rep);
72 }
73 mike 1.1
74 CIMParameter& operator=(const CIMParameter& x)
75 {
76 if (x._rep != _rep)
77 {
78 Dec(_rep);
79 Inc(_rep = x._rep);
80 }
81 return *this;
82 }
83
84 // Throws IllegalName if name argument not legal CIM identifier.
85
86 CIMParameter(
87 const String& name,
88 CIMType type,
89 Boolean isArray = false,
90 Uint32 arraySize = 0,
91 const String& referenceClassName = String::EMPTY)
92 {
93 _rep = new CIMParameterRep(
94 mike 1.1 name, type, isArray, arraySize, referenceClassName);
95 }
96
97 ~CIMParameter()
98 {
99 Dec(_rep);
100 }
101
102 const String& getName() const
103 {
104 _checkRep();
105 return _rep->getName();
106 }
107
108 // Throws IllegalName if name argument not legal CIM identifier.
109
110 void setName(const String& name)
111 {
112 _checkRep();
113 _rep->setName(name);
114 }
115 mike 1.1
116 Boolean isArray() const
117 {
118 _checkRep();
119 return _rep->isArray();
120 }
121
122 Uint32 getAraySize() const
123 {
124 _checkRep();
125 return _rep->getAraySize();
126 }
127
128 const String& getReferenceClassName() const
129 {
130 _checkRep();
131 return _rep->getReferenceClassName();
132 }
133
134 CIMType getType() const
135 {
136 mike 1.1 _checkRep();
137 return _rep->getType();
138 }
139
140 void setType(CIMType type);
141
142 // Throws AlreadyExists.
143
144 CIMParameter& addQualifier(const CIMQualifier& x)
145 {
146 _checkRep();
147 _rep->addQualifier(x);
148 return *this;
149 }
150
151 Uint32 findQualifier(const String& name)
152 {
153 _checkRep();
154 return _rep->findQualifier(name);
155 }
156
157 mike 1.1 Uint32 findQualifier(const String& name) const
158 {
159 _checkRep();
160 return _rep->findQualifier(name);
161 }
162
163 CIMQualifier getQualifier(Uint32 pos)
164 {
165 _checkRep();
166 return _rep->getQualifier(pos);
167 }
168
169 CIMConstQualifier getQualifier(Uint32 pos) const
170 {
171 _checkRep();
172 return _rep->getQualifier(pos);
173 }
174
175 Uint32 getQualifierCount() const
176 {
177 _checkRep();
178 mike 1.1 return _rep->getQualifierCount();
179 }
180
181 void resolve(DeclContext* declContext, const String& nameSpace)
182 {
183 _checkRep();
184 _rep->resolve(declContext, nameSpace);
185 }
186
187 operator int() const { return _rep != 0; }
188
189 void toXml(Array<Sint8>& out) const
190 {
191 _checkRep();
192 _rep->toXml(out);
193 }
194
195 void print() const
196 {
197 _checkRep();
198 _rep->print();
199 mike 1.1 }
200
201 Boolean identical(const CIMConstParameter& x) const;
202
203 CIMParameter clone() const
204 {
205 return CIMParameter(_rep->clone());
206 }
207
208 private:
209
210 CIMParameter(CIMParameterRep* rep) : _rep(rep)
211 {
212 }
213
214 void _checkRep() const
215 {
216 if (!_rep)
217 throw UnitializedHandle();
218 }
219
220 mike 1.1 CIMParameterRep* _rep;
221 friend class CIMConstParameter;
222 };
223
224 ////////////////////////////////////////////////////////////////////////////////
225 //
226 // CIMConstParameter
227 //
228 ////////////////////////////////////////////////////////////////////////////////
229
230 class PEGASUS_COMMON_LINKAGE CIMConstParameter
231 {
232 public:
233
234 CIMConstParameter() : _rep(0)
235 {
236
237 }
238
239 CIMConstParameter(const CIMConstParameter& x)
240 {
241 mike 1.1 Inc(_rep = x._rep);
242 }
243
244 CIMConstParameter(const CIMParameter& x)
245 {
246 Inc(_rep = x._rep);
247 }
248
249 CIMConstParameter& operator=(const CIMConstParameter& x)
250 {
251 if (x._rep != _rep)
252 {
253 Dec(_rep);
254 Inc(_rep = x._rep);
255 }
256 return *this;
257 }
258
259 CIMConstParameter& operator=(const CIMParameter& x)
260 {
261 if (x._rep != _rep)
262 mike 1.1 {
263 Dec(_rep);
264 Inc(_rep = x._rep);
265 }
266 return *this;
267 }
268
269 // Throws IllegalName if name argument not legal CIM identifier.
270
271 CIMConstParameter(
272 const String& name,
273 CIMType type,
274 Boolean isArray = false,
275 Uint32 arraySize = 0,
276 const String& referenceClassName = String::EMPTY)
277 {
278 _rep = new CIMParameterRep(
279 name, type, isArray, arraySize, referenceClassName);
280 }
281
282 ~CIMConstParameter()
283 mike 1.1 {
284 Dec(_rep);
285 }
286
287 const String& getName() const
288 {
289 _checkRep();
290 return _rep->getName();
291 }
292
293 Boolean isArray() const
294 {
295 _checkRep();
296 return _rep->isArray();
297 }
298
299 Uint32 getAraySize() const
300 {
301 _checkRep();
302 return _rep->getAraySize();
303 }
304 mike 1.1
305 const String& getReferenceClassName() const
306 {
307 _checkRep();
308 return _rep->getReferenceClassName();
309 }
310
311 CIMType getType() const
312 {
313 _checkRep();
314 return _rep->getType();
315 }
316
317 Uint32 findQualifier(const String& name) const
318 {
319 _checkRep();
320 return _rep->findQualifier(name);
321 }
322
323 CIMConstQualifier getQualifier(Uint32 pos) const
324 {
325 mike 1.1 _checkRep();
326 return _rep->getQualifier(pos);
327 }
328
329 Uint32 getQualifierCount() const
330 {
331 _checkRep();
332 return _rep->getQualifierCount();
333 }
334
335 operator int() const { return _rep != 0; }
336
337 void toXml(Array<Sint8>& out) const
338 {
339 _checkRep();
340 _rep->toXml(out);
341 }
342
343 void print() const
344 {
345 _checkRep();
346 mike 1.1 _rep->print();
347 }
348
349 Boolean identical(const CIMConstParameter& x) const
350 {
351 x._checkRep();
352 _checkRep();
353 return _rep->identical(x._rep);
354 }
355
356 CIMParameter clone() const
357 {
358 return CIMParameter(_rep->clone());
359 }
360
361 private:
362
363 void _checkRep() const
364 {
365 if (!_rep)
366 throw UnitializedHandle();
367 mike 1.1 }
368
369 CIMParameterRep* _rep;
370 friend class CIMParameter;
371 };
372
373 PEGASUS_NAMESPACE_END
374
375 #endif /* Pegasus_Parameter_h */
|
Return to
CIMParameter.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common