1 karl 1.30 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.9 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.9 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.12 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.30 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 karl 1.30 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "XmlWriter.h"
35 #include "XmlReader.h"
36 #include "XmlParser.h"
37 #include "CIMName.h"
|
38 r.kieninger 1.27 #include "CIMNameUnchecked.h"
|
39 schuur 1.1 #include "BinaryStreamer.h"
40 #include "CIMClassRep.h"
41 #include "CIMInstanceRep.h"
42 #include "CIMMethodRep.h"
43 #include "CIMParameterRep.h"
44 #include "CIMPropertyRep.h"
45 #include "CIMQualifierRep.h"
46 #include "CIMValue.h"
47 #include "CIMValueRep.h"
|
48 jim.wunderlich 1.21 #include "Packer.h"
49
50 #define MAGIC_BYTE Uint8(0x11)
51 #define VERSION_NUMBER Uint8(1)
|
52 schuur 1.1
53 PEGASUS_USING_STD;
54
55 PEGASUS_NAMESPACE_BEGIN
56
|
57 jim.wunderlich 1.21 enum BinaryObjectType
58 {
59 BINARY_CLASS,
60 BINARY_INSTANCE,
|
61 jim.wunderlich 1.22 BINARY_QUALIFIER_DECL
|
62 jim.wunderlich 1.21 };
|
63 konrad.r 1.8
|
64 mike 1.24 static inline void _packMagicByte(Buffer& out)
|
65 schuur 1.1 {
|
66 jim.wunderlich 1.21 Packer::packUint8(out, MAGIC_BYTE);
|
67 schuur 1.1 }
68
|
69 mike 1.24 static void _checkMagicByte(const Buffer& in, Uint32& pos)
|
70 schuur 1.1 {
|
71 jim.wunderlich 1.21 Uint8 magicByte;
72 Packer::unpackUint8(in, pos, magicByte);
73
74 if (magicByte != MAGIC_BYTE)
|
75 david.dillard 1.28 throw BinException("Bad magic byte");
|
76 schuur 1.1 }
77
|
78 jim.wunderlich 1.21 struct Header
79 {
80 // A version number for this message.
81 Uint8 versionNumber;
82
83 // The object type (see BinaryObjectType enum).
|
84 david.dillard 1.28 Uint8 objectType;
|
85 jim.wunderlich 1.21 };
86
|
87 mike 1.24 static void _packHeader(Buffer& out, Uint8 objectType)
|
88 schuur 1.1 {
|
89 jim.wunderlich 1.21 Packer::packUint8(out, VERSION_NUMBER);
90 Packer::packUint8(out, objectType);
|
91 schuur 1.1 }
92
|
93 jim.wunderlich 1.21 static void _checkHeader(
|
94 mike 1.24 const Buffer& in, Uint32& pos, Uint8 expectedObjectType)
|
95 schuur 1.1 {
|
96 jim.wunderlich 1.21 Header header;
97 Packer::unpackUint8(in, pos, header.versionNumber);
98 Packer::unpackUint8(in, pos, header.objectType);
99
100 if (header.objectType != expectedObjectType)
|
101 david.dillard 1.28 throw BinException("Unexpected object type");
|
102 jim.wunderlich 1.21
103 if (header.versionNumber != VERSION_NUMBER)
|
104 david.dillard 1.28 throw BinException("Unsupported version");
|
105 schuur 1.1 }
106
|
107 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Boolean& x)
|
108 schuur 1.1 {
|
109 jim.wunderlich 1.21 Packer::unpackBoolean(in, pos, x);
|
110 schuur 1.1 }
111
|
112 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Uint8& x)
|
113 schuur 1.1 {
|
114 jim.wunderlich 1.21 Packer::unpackUint8(in, pos, x);
|
115 schuur 1.1 }
116
|
117 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Sint8& x)
|
118 jim.wunderlich 1.21 {
119 Packer::unpackUint8(in, pos, (Uint8&)x);
120 }
|
121 schuur 1.1
|
122 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Uint16& x)
|
123 jim.wunderlich 1.21 {
124 Packer::unpackUint16(in, pos, x);
125 }
|
126 schuur 1.1
|
127 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Sint16& x)
|
128 schuur 1.1 {
|
129 jim.wunderlich 1.21 Packer::unpackUint16(in, pos, (Uint16&)x);
|
130 schuur 1.1 }
131
|
132 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Uint32& x)
|
133 schuur 1.1 {
|
134 jim.wunderlich 1.21 Packer::unpackUint32(in, pos, x);
|
135 schuur 1.1 }
136
|
137 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Sint32& x)
|
138 schuur 1.1 {
|
139 jim.wunderlich 1.21 Packer::unpackUint32(in, pos, (Uint32&)x);
|
140 schuur 1.1 }
141
|
142 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Uint64& x)
|
143 schuur 1.1 {
|
144 jim.wunderlich 1.21 Packer::unpackUint64(in, pos, x);
|
145 schuur 1.1 }
146
|
147 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Sint64& x)
|
148 schuur 1.1 {
|
149 jim.wunderlich 1.21 Packer::unpackUint64(in, pos, (Uint64&)x);
|
150 schuur 1.1 }
151
|
152 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Real32& x)
|
153 schuur 1.1 {
|
154 jim.wunderlich 1.21 Packer::unpackReal32(in, pos, x);
|
155 schuur 1.1 }
156
|
157 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Real64& x)
|
158 jim.wunderlich 1.21 {
159 Packer::unpackReal64(in, pos, x);
160 }
|
161 schuur 1.1
|
162 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, Char16& x)
|
163 jim.wunderlich 1.21 {
164 Packer::unpackChar16(in, pos, x);
165 }
|
166 schuur 1.1
|
167 mike 1.24 inline void _unpack(const Buffer& in, Uint32& pos, String& x)
|
168 schuur 1.1 {
|
169 jim.wunderlich 1.21 Packer::unpackString(in, pos, x);
170 }
|
171 konrad.r 1.5
|
172 mike 1.24 void _unpack(const Buffer& in, Uint32& pos, CIMDateTime& x)
|
173 jim.wunderlich 1.21 {
174 String tmp;
175 Packer::unpackString(in, pos, tmp);
176 x.set(tmp);
|
177 schuur 1.1 }
178
|
179 mike 1.24 void _unpack(const Buffer& in, Uint32& pos, CIMObjectPath& x)
|
180 schuur 1.1 {
|
181 jim.wunderlich 1.21 String tmp;
182 Packer::unpackString(in, pos, tmp);
183 x.set(tmp);
|
184 schuur 1.1 }
185
|
186 dave.sudlik 1.29 void _unpack(const Buffer& in, Uint32& pos, CIMObject& x)
187 {
188 String tmp_String;
189 Packer::unpackString(in, pos, tmp_String);
|
190 kumpf 1.35
|
191 dave.sudlik 1.29 if (tmp_String.size() == 0)
192 {
|
193 dave.sudlik 1.31 // This should not occur since _unpackValue() won't call _unpack()
194 // if the value is Null.
195 PEGASUS_ASSERT(false);
|
196 dave.sudlik 1.29 }
197 else
198 {
199 // Convert the non-NULL string to a CIMObject (containing either a
200 // CIMInstance or a CIMClass).
|
201 kumpf 1.35
|
202 dave.sudlik 1.29 // First we need to create a new "temporary" XmlParser that is
203 // just the value of the Embedded Object in String representation.
204 CString cstr = tmp_String.getCString();
205 char* tmp_buffer = (char*)(const char*)cstr;
206 XmlParser tmp_parser(tmp_buffer);
207
|
208 kumpf 1.35 // The next bit of logic constructs a CIMObject from the Embedded
209 // Object String.
|
210 dave.sudlik 1.29 // It is similar to the method XmlReader::getValueObjectElement().
211 CIMInstance cimInstance;
212 CIMClass cimClass;
213
214 if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
215 {
216 x = CIMObject(cimInstance);
217 }
218 else if (XmlReader::getClassElement(tmp_parser, cimClass))
219 {
220 x = CIMObject(cimClass);
221 }
222 else
223 {
|
224 kumpf 1.35 // change "element" to "embedded object"
225 MessageLoaderParms mlParms(
226 "Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
227 "Expected INSTANCE or CLASS element");
|
228 dave.sudlik 1.29
229 throw XmlValidationError(0, mlParms);
230 }
231 }
232 }
|
233 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
234 a.dunfey 1.32 void _unpack(const Buffer& in, Uint32& pos, CIMInstance& x)
235 {
236 CIMObject tmp;
237 _unpack(in, pos, tmp);
238 x = CIMInstance(tmp);
239 }
|
240 a.dunfey 1.33 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
241 a.dunfey 1.32
|
242 jim.wunderlich 1.21 template<class T>
243 struct UnpackArray
244 {
245 static void func(
|
246 david.dillard 1.28 const Buffer& in, Uint32& pos, Uint32 n, CIMValue& value)
|
247 jim.wunderlich 1.21 {
|
248 david.dillard 1.28 Array<T> array;
249 array.reserveCapacity(n);
|
250 jim.wunderlich 1.21
|
251 david.dillard 1.28 for (Uint32 i = 0; i < n; i++)
252 {
253 T tmp;
254 _unpack(in, pos, tmp);
255 array.append(tmp);
256 }
|
257 jim.wunderlich 1.21
|
258 david.dillard 1.28 value.set(array);
|
259 jim.wunderlich 1.21 }
260 };
261
262 template<class T>
263 struct UnpackScalar
|
264 schuur 1.1 {
|
265 jim.wunderlich 1.21 static void func(
|
266 david.dillard 1.28 const Buffer& in, Uint32& pos, CIMValue& value)
|
267 jim.wunderlich 1.21 {
|
268 david.dillard 1.28 T tmp;
269 _unpack(in, pos, tmp);
270 value.set(tmp);
|
271 jim.wunderlich 1.21 }
272 };
273
274 template<class OBJECT>
275 struct UnpackQualifiers
276 {
|
277 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
|
278 jim.wunderlich 1.21 {
|
279 david.dillard 1.28 Uint32 n;
280 Packer::unpackSize(in, pos, n);
|
281 jim.wunderlich 1.21
|
282 david.dillard 1.28 CIMQualifier q;
|
283 jim.wunderlich 1.21
|
284 david.dillard 1.28 for (size_t i = 0; i < n; i++)
285 {
286 BinaryStreamer::_unpackQualifier(in, pos, q);
287 x.addQualifier(q);
288 }
|
289 jim.wunderlich 1.21 }
290 };
291
292 template<class REP>
293 struct PackQualifiers
294 {
|
295 mike 1.24 static void func(Buffer& out, REP* rep)
|
296 jim.wunderlich 1.21 {
|
297 david.dillard 1.28 Uint32 n = rep->getQualifierCount();
298 Packer::packSize(out, n);
|
299 jim.wunderlich 1.21
|
300 david.dillard 1.28 for (Uint32 i = 0; i < n; i++)
301 BinaryStreamer::_packQualifier(out, rep->getQualifier(i));
|
302 jim.wunderlich 1.21 }
303 };
304
305 template<class OBJECT>
306 struct UnpackProperties
307 {
|
308 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
|
309 jim.wunderlich 1.21 {
|
310 david.dillard 1.28 Uint32 n;
311 Packer::unpackSize(in, pos, n);
|
312 jim.wunderlich 1.21
|
313 david.dillard 1.28 CIMProperty p;
|
314 jim.wunderlich 1.21
|
315 david.dillard 1.28 for (size_t i = 0; i < n; i++)
316 {
317 BinaryStreamer::_unpackProperty(in, pos, p);
318 x.addProperty(p);
319 }
|
320 jim.wunderlich 1.21 }
321 };
322
323 template<class OBJECT>
324 struct UnpackMethods
325 {
|
326 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
|
327 jim.wunderlich 1.21 {
|
328 david.dillard 1.28 Uint32 n;
329 Packer::unpackSize(in, pos, n);
|
330 jim.wunderlich 1.21
|
331 david.dillard 1.28 CIMMethod m;
|
332 jim.wunderlich 1.21
|
333 david.dillard 1.28 for (size_t i = 0; i < n; i++)
334 {
335 BinaryStreamer::_unpackMethod(in, pos, m);
336 x.addMethod(m);
337 }
|
338 jim.wunderlich 1.21 }
339 };
340
|
341 mike 1.24 void BinaryStreamer::_packName(Buffer& out, const CIMName& x)
|
342 jim.wunderlich 1.21 {
343 Packer::packString(out, x.getString());
|
344 schuur 1.1 }
345
|
346 jim.wunderlich 1.21 void BinaryStreamer::_unpackName(
|
347 mike 1.24 const Buffer& in, Uint32& pos, CIMName& x)
|
348 schuur 1.1 {
|
349 jim.wunderlich 1.21 String tmp;
350 Packer::unpackString(in, pos, tmp);
|
351 r.kieninger 1.27 x = tmp.size() ? CIMNameUnchecked(tmp) : CIMName();
|
352 schuur 1.1 }
353
|
354 mike 1.24 void BinaryStreamer::_packQualifier(Buffer& out, const CIMQualifier& x)
|
355 schuur 1.1 {
|
356 jim.wunderlich 1.21 CIMQualifierRep* rep = x._rep;
357
358 _packMagicByte(out);
359 _packName(out, rep->getName());
360 _packValue(out, rep->getValue());
361 _packFlavor(out, rep->getFlavor());
362 Packer::packBoolean(out, rep->getPropagated());
|
363 schuur 1.1 }
364
|
365 jim.wunderlich 1.21 void BinaryStreamer::_unpackQualifier(
|
366 mike 1.24 const Buffer& in, Uint32& pos, CIMQualifier& x)
|
367 schuur 1.1 {
|
368 jim.wunderlich 1.21 _checkMagicByte(in, pos);
369
370 CIMName name;
371 _unpackName(in, pos, name);
372
373 CIMValue value;
374 _unpackValue(in, pos, value);
375
376 CIMFlavor flavor;
377 BinaryStreamer::_unpackFlavor(in, pos, flavor);
378
379 Boolean propagated;
380 Packer::unpackBoolean(in, pos, propagated);
381
382 x = CIMQualifier(name, value, flavor, propagated);
|
383 schuur 1.1 }
384
|
385 mike 1.24 void BinaryStreamer::_packValue(Buffer& out, const CIMValue& x)
|
386 jim.wunderlich 1.21 {
387 CIMValueRep* rep = x._rep;
388
389 _packMagicByte(out);
390 _packType(out, x.getType());
391 Packer::packBoolean(out, x.isArray());
392
393 Uint32 n = x.getArraySize();
|
394 schuur 1.1
|
395 jim.wunderlich 1.21 if (x.isArray())
|
396 david.dillard 1.28 Packer::packSize(out, n);
|
397 schuur 1.1
|
398 jim.wunderlich 1.21 Packer::packBoolean(out, x.isNull());
|
399 schuur 1.1
|
400 jim.wunderlich 1.21 if (x.isNull())
|
401 david.dillard 1.28 return;
|
402 jim.wunderlich 1.21
403 if (x.isArray())
404 {
|
405 david.dillard 1.28 switch (x.getType())
406 {
407 case CIMTYPE_BOOLEAN:
408 Packer::packBoolean(
409 out, CIMValueType<Boolean>::aref(rep).getData(), n);
410 break;
411
412 case CIMTYPE_SINT8:
413 case CIMTYPE_UINT8:
414 Packer::packUint8(
415 out, CIMValueType<Uint8>::aref(rep).getData(), n);
416 break;
417
418 case CIMTYPE_SINT16:
419 case CIMTYPE_UINT16:
420 case CIMTYPE_CHAR16:
421 Packer::packUint16(
422 out, CIMValueType<Uint16>::aref(rep).getData(), n);
423 break;
424
425 case CIMTYPE_SINT32:
426 david.dillard 1.28 case CIMTYPE_UINT32:
427 case CIMTYPE_REAL32:
428 Packer::packUint32(
429 out, CIMValueType<Uint32>::aref(rep).getData(), n);
430 break;
431
432 case CIMTYPE_SINT64:
433 case CIMTYPE_UINT64:
434 case CIMTYPE_REAL64:
435 Packer::packUint64(
436 out, CIMValueType<Uint64>::aref(rep).getData(), n);
437 break;
438
439 case CIMTYPE_STRING:
440 Packer::packString(out,
441 CIMValueType<String>::aref(rep).getData(), n);
442 break;
443
444 case CIMTYPE_DATETIME:
445 {
446 const Array<CIMDateTime>& a =
447 david.dillard 1.28 CIMValueType<CIMDateTime>::aref(rep);
448
449 for (Uint32 i = 0; i < n; i++)
450 Packer::packString(out, a[i].toString());
451 break;
452 }
453
454 case CIMTYPE_REFERENCE:
455 {
456 const Array<CIMObjectPath>& a =
457 CIMValueType<CIMObjectPath>::aref(rep);
458
459 for (Uint32 i = 0; i < n; i++)
460 Packer::packString(out, a[i].toString());
461 break;
462 }
463
464 case CIMTYPE_OBJECT:
|
465 dave.sudlik 1.29 {
|
466 kumpf 1.35 const Array<CIMObject>& a =
|
467 dave.sudlik 1.29 CIMValueType<CIMObject>::aref(rep);
|
468 kumpf 1.35
469 for (Uint32 i = 0; i < n; i++)
|
470 dave.sudlik 1.29 Packer::packString(out, a[i].toString());
|
471 david.dillard 1.28 break;
|
472 dave.sudlik 1.29 }
|
473 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
474 a.dunfey 1.32 case CIMTYPE_INSTANCE:
475 {
|
476 kumpf 1.35 const Array<CIMInstance>& a =
|
477 a.dunfey 1.32 CIMValueType<CIMInstance>::aref(rep);
|
478 kumpf 1.35
479 for (Uint32 i = 0; i < n; i++)
|
480 a.dunfey 1.32 {
481 CIMObject tmp(a[i]);
482 Packer::packString(out, tmp.toString());
483 }
484 break;
485 }
|
486 a.dunfey 1.34 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
487 david.dillard 1.28 }
|
488 jim.wunderlich 1.21 }
489 else
490 {
|
491 david.dillard 1.28 switch (x.getType())
492 {
493 case CIMTYPE_BOOLEAN:
494 Packer::packBoolean(out, rep->u._booleanValue);
495 break;
496
497 case CIMTYPE_SINT8:
498 case CIMTYPE_UINT8:
499 Packer::packUint8(out, rep->u._uint8Value);
500 break;
501
502 case CIMTYPE_SINT16:
503 case CIMTYPE_UINT16:
504 case CIMTYPE_CHAR16:
505 Packer::packUint16(out, rep->u._uint16Value);
506 break;
507
508 case CIMTYPE_SINT32:
509 case CIMTYPE_UINT32:
510 case CIMTYPE_REAL32:
511 Packer::packUint32(out, rep->u._uint32Value);
512 david.dillard 1.28 break;
513
514 case CIMTYPE_SINT64:
515 case CIMTYPE_UINT64:
516 case CIMTYPE_REAL64:
517 Packer::packUint64(out, rep->u._uint64Value);
518 break;
519
520 case CIMTYPE_STRING:
521 Packer::packString(out, CIMValueType<String>::ref(rep));
522 break;
523
524 case CIMTYPE_DATETIME:
525 Packer::packString(
526 out, CIMValueType<CIMDateTime>::ref(rep).toString());
527 break;
528
529 case CIMTYPE_REFERENCE:
530 Packer::packString(
531 out, CIMValueType<CIMObjectPath>::ref(rep).toString());
532 break;
533 david.dillard 1.28
534 case CIMTYPE_OBJECT:
|
535 dave.sudlik 1.29 Packer::packString(
536 out, CIMValueType<CIMObject>::ref(rep).toString());
|
537 david.dillard 1.28 break;
|
538 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
539 a.dunfey 1.32 case CIMTYPE_INSTANCE:
540 {
541 CIMObject tmp(CIMValueType<CIMInstance>::ref(rep));
542 Packer::packString(
543 out, tmp.toString());
544 break;
545 }
|
546 a.dunfey 1.33 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
547 david.dillard 1.28 }
|
548 jim.wunderlich 1.21 }
|
549 schuur 1.1 }
550
|
551 jim.wunderlich 1.21 void BinaryStreamer::_unpackValue(
|
552 mike 1.24 const Buffer& in, Uint32& pos, CIMValue& x)
|
553 jim.wunderlich 1.21 {
554 _checkMagicByte(in, pos);
555
556 CIMType type;
557 _unpackType(in, pos, type);
558
559 Boolean isArray;
560 Packer::unpackBoolean(in, pos, isArray);
|
561 schuur 1.1
|
562 jim.wunderlich 1.23 Uint32 arraySize = 0;
|
563 konrad.r 1.8
|
564 jim.wunderlich 1.21 if (isArray)
|
565 david.dillard 1.28 Packer::unpackSize(in, pos, arraySize);
|
566 schuur 1.1
|
567 jim.wunderlich 1.21 Boolean isNull;
568 Packer::unpackBoolean(in, pos, isNull);
|
569 schuur 1.1
|
570 jim.wunderlich 1.21 if (isNull)
571 {
|
572 david.dillard 1.28 x = CIMValue(type, isArray, arraySize);
573 return;
|
574 jim.wunderlich 1.21 }
|
575 schuur 1.1
|
576 jim.wunderlich 1.21 if (isArray)
577 {
|
578 david.dillard 1.28 CIMValue cimValue(type, isArray, arraySize);
|
579 jim.wunderlich 1.21
|
580 david.dillard 1.28 switch (type)
581 {
582 case CIMTYPE_BOOLEAN:
583 UnpackArray<Boolean>::func(in, pos, arraySize, cimValue);
584 break;
585
586 case CIMTYPE_UINT8:
587 UnpackArray<Uint8>::func(in, pos, arraySize, cimValue);
588 break;
589
590 case CIMTYPE_SINT8:
591 UnpackArray<Sint8>::func(in, pos, arraySize, cimValue);
592 break;
593
594 case CIMTYPE_UINT16:
595 UnpackArray<Uint16>::func(in, pos, arraySize, cimValue);
596 break;
597
598 case CIMTYPE_SINT16:
599 UnpackArray<Sint16>::func(in, pos, arraySize, cimValue);
600 break;
601 david.dillard 1.28
602 case CIMTYPE_UINT32:
603 UnpackArray<Uint32>::func(in, pos, arraySize, cimValue);
604 break;
605
606 case CIMTYPE_SINT32:
607 UnpackArray<Sint32>::func(in, pos, arraySize, cimValue);
608 break;
609
610 case CIMTYPE_UINT64:
611 UnpackArray<Uint64>::func(in, pos, arraySize, cimValue);
612 break;
613
614 case CIMTYPE_SINT64:
615 UnpackArray<Sint64>::func(in, pos, arraySize, cimValue);
616 break;
617
618 case CIMTYPE_REAL32:
619 UnpackArray<Real32>::func(in, pos, arraySize, cimValue);
620 break;
621
622 david.dillard 1.28 case CIMTYPE_REAL64:
623 UnpackArray<Real64>::func(in, pos, arraySize, cimValue);
624 break;
625
626 case CIMTYPE_CHAR16:
627 UnpackArray<Char16>::func(in, pos, arraySize, cimValue);
628 break;
629
630 case CIMTYPE_STRING:
631 UnpackArray<String>::func(in, pos, arraySize, cimValue);
632 break;
633
634 case CIMTYPE_DATETIME:
635 UnpackArray<CIMDateTime>::func(in, pos, arraySize, cimValue);
636 break;
637
638 case CIMTYPE_REFERENCE:
639 UnpackArray<CIMObjectPath>::func(in, pos, arraySize, cimValue);
640 break;
641
642 case CIMTYPE_OBJECT:
|
643 dave.sudlik 1.29 UnpackArray<CIMObject>::func(in, pos, arraySize, cimValue);
|
644 david.dillard 1.28 break;
|
645 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
646 a.dunfey 1.32 case CIMTYPE_INSTANCE:
647 UnpackArray<CIMInstance>::func(in, pos, arraySize, cimValue);
648 break;
|
649 a.dunfey 1.33 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
650 david.dillard 1.28 }
|
651 schuur 1.1
|
652 david.dillard 1.28 x = cimValue;
|
653 jim.wunderlich 1.21 }
654 else
655 {
|
656 david.dillard 1.28 CIMValue cimValue(type, isArray);
|
657 jim.wunderlich 1.21
|
658 david.dillard 1.28 switch (type)
659 {
660 case CIMTYPE_BOOLEAN:
661 UnpackScalar<Boolean>::func(in, pos, cimValue);
662 break;
663
664 case CIMTYPE_UINT8:
665 UnpackScalar<Uint8>::func(in, pos, cimValue);
666 break;
667
668 case CIMTYPE_SINT8:
669 UnpackScalar<Sint8>::func(in, pos, cimValue);
670 break;
671
672 case CIMTYPE_UINT16:
673 UnpackScalar<Uint16>::func(in, pos, cimValue);
674 break;
675
676 case CIMTYPE_SINT16:
677 UnpackScalar<Sint16>::func(in, pos, cimValue);
678 break;
679 david.dillard 1.28
680 case CIMTYPE_UINT32:
681 UnpackScalar<Uint32>::func(in, pos, cimValue);
682 break;
683
684 case CIMTYPE_SINT32:
685 UnpackScalar<Sint32>::func(in, pos, cimValue);
686 break;
687
688 case CIMTYPE_UINT64:
689 UnpackScalar<Uint64>::func(in, pos, cimValue);
690 break;
691
692 case CIMTYPE_SINT64:
693 UnpackScalar<Sint64>::func(in, pos, cimValue);
694 break;
695
696 case CIMTYPE_REAL32:
697 UnpackScalar<Real32>::func(in, pos, cimValue);
698 break;
699
700 david.dillard 1.28 case CIMTYPE_REAL64:
701 UnpackScalar<Real64>::func(in, pos, cimValue);
702 break;
703
704 case CIMTYPE_CHAR16:
705 UnpackScalar<Char16>::func(in, pos, cimValue);
706 break;
707
708 case CIMTYPE_STRING:
709 UnpackScalar<String>::func(in, pos, cimValue);
710 break;
711
712 case CIMTYPE_DATETIME:
713 UnpackScalar<CIMDateTime>::func(in, pos, cimValue);
714 break;
715
716 case CIMTYPE_REFERENCE:
717 UnpackScalar<CIMObjectPath>::func(in, pos, cimValue);
718 break;
719
720 case CIMTYPE_OBJECT:
|
721 dave.sudlik 1.29 UnpackScalar<CIMObject>::func(in, pos, cimValue);
|
722 david.dillard 1.28 break;
|
723 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
724 a.dunfey 1.32 case CIMTYPE_INSTANCE:
725 UnpackScalar<CIMInstance>::func(in, pos, cimValue);
726 break;
|
727 a.dunfey 1.34 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
728 david.dillard 1.28 }
|
729 schuur 1.1
|
730 david.dillard 1.28 x = cimValue;
|
731 jim.wunderlich 1.21 }
|
732 schuur 1.1
|
733 jim.wunderlich 1.21 return;
734 }
|
735 schuur 1.1
|
736 mike 1.24 void BinaryStreamer::_packProperty(Buffer& out, const CIMProperty& x)
|
737 jim.wunderlich 1.21 {
738 CIMPropertyRep* rep = x._rep;
|
739 schuur 1.1
|
740 jim.wunderlich 1.21 _packMagicByte(out);
741 _packName(out, rep->getName());
742 _packValue(out, rep->getValue());
743 Packer::packSize(out, rep->getArraySize());
744 _packName(out, rep->getReferenceClassName());
745 _packName(out, rep->getClassOrigin());
746 Packer::packBoolean(out, rep->getPropagated());
747 PackQualifiers<CIMPropertyRep>::func(out, rep);
|
748 schuur 1.1 }
749
|
750 jim.wunderlich 1.21 void BinaryStreamer::_unpackProperty(
|
751 mike 1.24 const Buffer& in, Uint32& pos, CIMProperty& x)
|
752 jim.wunderlich 1.21 {
753 _checkMagicByte(in, pos);
|
754 schuur 1.1
|
755 jim.wunderlich 1.21 CIMName name;
756 _unpackName(in, pos, name);
|
757 schuur 1.1
|
758 jim.wunderlich 1.21 CIMValue value;
759 _unpackValue(in, pos, value);
|
760 schuur 1.1
|
761 jim.wunderlich 1.21 Uint32 arraySize;
762 Packer::unpackSize(in, pos, arraySize);
|
763 schuur 1.1
|
764 jim.wunderlich 1.21 CIMName referenceClassName;
765 _unpackName(in, pos, referenceClassName);
|
766 schuur 1.1
|
767 jim.wunderlich 1.21 CIMName classOrigin;
768 _unpackName(in, pos, classOrigin);
|
769 schuur 1.1
|
770 jim.wunderlich 1.21 Boolean propagated;
771 Packer::unpackBoolean(in, pos, propagated);
|
772 schuur 1.1
|
773 jim.wunderlich 1.21 CIMProperty cimProperty(
|
774 david.dillard 1.28 name, value, arraySize, referenceClassName, classOrigin, propagated);
|
775 schuur 1.1
|
776 jim.wunderlich 1.21 UnpackQualifiers<CIMProperty>::func(in, pos, cimProperty);
|
777 a.dunfey 1.33 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
778 kumpf 1.36 if (cimProperty.getType() == CIMTYPE_STRING)
|
779 a.dunfey 1.32 {
780 CIMType realType = CIMTYPE_STRING;
|
781 kumpf 1.36 if (cimProperty.findQualifier("EmbeddedInstance") != PEG_NOT_FOUND)
|
782 a.dunfey 1.32 {
783 // Note that this condition should only happen for properties in
784 // class definitions, and only NULL values are recognized. We
785 // currently don't handle embedded instance types with default
786 // values in the class definition.
787 PEGASUS_ASSERT(value.isNull());
788 realType = CIMTYPE_INSTANCE;
789 }
|
790 kumpf 1.36 else if (cimProperty.findQualifier("EmbeddedObject") != PEG_NOT_FOUND)
|
791 a.dunfey 1.32 {
792 // Note that this condition should only happen for properties in
793 // class definitions, and only NULL values are recognized. We
794 // currently don't handle embedded object types with default
795 // values in the class definition.
796 PEGASUS_ASSERT(value.isNull());
797 realType = CIMTYPE_OBJECT;
798 }
799
|
800 kumpf 1.36 if (realType != CIMTYPE_STRING)
|
801 a.dunfey 1.32 {
802 CIMProperty tmpProperty(name, CIMValue(realType, value.isArray()),
803 arraySize, referenceClassName, classOrigin, propagated);
|
804 kumpf 1.36 for (unsigned int i = 0, n = cimProperty.getQualifierCount();
805 i < n; ++i)
|
806 a.dunfey 1.32 {
807 tmpProperty.addQualifier(cimProperty.getQualifier(i));
808 }
809 cimProperty = tmpProperty;
810 }
811 }
|
812 a.dunfey 1.33 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
813 jim.wunderlich 1.21 x = cimProperty;
|
814 schuur 1.1 }
815
|
816 mike 1.24 void BinaryStreamer::_packParameter(Buffer& out, const CIMParameter& x)
|
817 jim.wunderlich 1.21 {
818 CIMParameterRep* rep = x._rep;
|
819 schuur 1.1
|
820 jim.wunderlich 1.21 _packMagicByte(out);
821 _packName(out, rep->getName());
822 _packType(out, rep->getType());
823 Packer::packBoolean(out, rep->isArray());
824 Packer::packSize(out, rep->getArraySize());
825 _packName(out, rep->getReferenceClassName());
826 PackQualifiers<CIMParameterRep>::func(out, rep);
827 }
828
829 void BinaryStreamer::_unpackParameter(
|
830 mike 1.24 const Buffer& in, Uint32& pos, CIMParameter& x)
|
831 schuur 1.1 {
|
832 jim.wunderlich 1.21 _checkMagicByte(in, pos);
|
833 konrad.r 1.8
|
834 jim.wunderlich 1.21 CIMName name;
835 _unpackName(in, pos, name);
|
836 konrad.r 1.8
|
837 jim.wunderlich 1.21 CIMType type;
838 _unpackType(in, pos, type);
|
839 schuur 1.1
|
840 jim.wunderlich 1.21 Boolean isArray;
841 Packer::unpackBoolean(in, pos, isArray);
|
842 schuur 1.1
|
843 jim.wunderlich 1.21 Uint32 arraySize;
844 Packer::unpackSize(in, pos, arraySize);
|
845 schuur 1.1
|
846 jim.wunderlich 1.21 CIMName referenceClassName;
847 _unpackName(in, pos, referenceClassName);
|
848 schuur 1.1
|
849 jim.wunderlich 1.21 CIMParameter cimParameter(
|
850 david.dillard 1.28 name, type, isArray, arraySize, referenceClassName);
|
851 schuur 1.1
|
852 jim.wunderlich 1.21 UnpackQualifiers<CIMParameter>::func(in, pos, cimParameter);
|
853 schuur 1.1
|
854 jim.wunderlich 1.21 x = cimParameter;
855 }
|
856 schuur 1.1
|
857 mike 1.24 void BinaryStreamer::_packParameters(Buffer& out, CIMMethodRep* rep)
|
858 jim.wunderlich 1.21 {
859 Uint32 n = rep->getParameterCount();
860 Packer::packSize(out, n);
|
861 schuur 1.1
|
862 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
|
863 david.dillard 1.28 BinaryStreamer::_packParameter(out, rep->getParameter(i));
|
864 schuur 1.1 }
865
|
866 jim.wunderlich 1.21 void BinaryStreamer::_unpackParameters(
|
867 mike 1.24 const Buffer& in, Uint32& pos, CIMMethod& x)
|
868 jim.wunderlich 1.21 {
869 Uint32 n;
870 Packer::unpackSize(in, pos, n);
|
871 schuur 1.1
|
872 jim.wunderlich 1.21 for (size_t i = 0; i < n; i++)
873 {
|
874 david.dillard 1.28 CIMParameter q;
875 _unpackParameter(in, pos, q);
876 x.addParameter(q);
|
877 jim.wunderlich 1.21 }
878 }
|
879 schuur 1.1
|
880 mike 1.24 void BinaryStreamer::_packMethod(Buffer& out, const CIMMethod& x)
|
881 jim.wunderlich 1.21 {
882 CIMMethodRep* rep = x._rep;
|
883 schuur 1.1
|
884 jim.wunderlich 1.21 _packMagicByte(out);
885 _packName(out, rep->getName());
886 _packType(out, rep->getType());
887 _packName(out, rep->getClassOrigin());
888 Packer::packBoolean(out, rep->getPropagated());
889 PackQualifiers<CIMMethodRep>::func(out, rep);
890 _packParameters(out, rep);
891 }
|
892 schuur 1.1
|
893 jim.wunderlich 1.21 void BinaryStreamer::_unpackMethod(
|
894 mike 1.24 const Buffer& in, Uint32& pos, CIMMethod& x)
|
895 schuur 1.1 {
|
896 jim.wunderlich 1.21 _checkMagicByte(in, pos);
|
897 schuur 1.1
|
898 jim.wunderlich 1.21 CIMName name;
899 _unpackName(in, pos, name);
|
900 schuur 1.1
|
901 jim.wunderlich 1.21 CIMType type;
902 _unpackType(in, pos, type);
|
903 schuur 1.1
|
904 jim.wunderlich 1.21 CIMName classOrigin;
905 _unpackName(in, pos, classOrigin);
|
906 schuur 1.1
|
907 jim.wunderlich 1.21 Boolean propagated;
908 Packer::unpackBoolean(in, pos, propagated);
|
909 schuur 1.1
|
910 jim.wunderlich 1.21 CIMMethod cimMethod(name, type, classOrigin, propagated);
911 UnpackQualifiers<CIMMethod>::func(in, pos, cimMethod);
912 _unpackParameters(in, pos, cimMethod);
|
913 schuur 1.1
|
914 jim.wunderlich 1.21 x = cimMethod;
|
915 schuur 1.1 }
916
|
917 mike 1.24 void BinaryStreamer::_packObjectPath(Buffer& out, const CIMObjectPath& x)
|
918 jim.wunderlich 1.21 {
919 Packer::packString(out, x.toString());
920 }
|
921 schuur 1.1
|
922 jim.wunderlich 1.21 void BinaryStreamer::_unpackObjectPath(
|
923 mike 1.24 const Buffer& in, Uint32& pos, CIMObjectPath& x)
|
924 schuur 1.1 {
|
925 jim.wunderlich 1.21 String tmp;
926 Packer::unpackString(in, pos, tmp);
927 x = CIMObjectPath(tmp);
928 }
|
929 konrad.r 1.8
|
930 mike 1.24 void BinaryStreamer::_packProperties(Buffer& out, CIMObjectRep* rep)
|
931 jim.wunderlich 1.21 {
932 Uint32 n = rep->getPropertyCount();
933 Packer::packSize(out, n);
|
934 schuur 1.1
|
935 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
|
936 david.dillard 1.28 BinaryStreamer::_packProperty(out, rep->getProperty(i));
|
937 jim.wunderlich 1.21 }
|
938 schuur 1.1
|
939 mike 1.24 void BinaryStreamer::_packMethods(Buffer& out, CIMClassRep* rep)
|
940 jim.wunderlich 1.21 {
941 Uint32 n = rep->getMethodCount();
942 Packer::packSize(out, n);
|
943 schuur 1.1
|
944 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
|
945 david.dillard 1.28 BinaryStreamer::_packMethod(out, rep->getMethod(i));
|
946 jim.wunderlich 1.21 }
|
947 schuur 1.1
|
948 mike 1.24 void BinaryStreamer::_packScope(Buffer& out, const CIMScope& x)
|
949 jim.wunderlich 1.21 {
950 Packer::packUint32(out, x.cimScope);
951 }
|
952 schuur 1.1
|
953 jim.wunderlich 1.21 void BinaryStreamer::_unpackScope(
|
954 mike 1.24 const Buffer& in, Uint32& pos, CIMScope& x)
|
955 jim.wunderlich 1.21 {
956 Packer::unpackUint32(in, pos, x.cimScope);
957 }
|
958 schuur 1.1
|
959 mike 1.24 void BinaryStreamer::_packFlavor(Buffer& out, const CIMFlavor& x)
|
960 jim.wunderlich 1.21 {
961 Packer::packUint32(out, x.cimFlavor);
|
962 schuur 1.1 }
963
|
964 jim.wunderlich 1.21 void BinaryStreamer::_unpackFlavor(
|
965 mike 1.24 const Buffer& in, Uint32& pos, CIMFlavor& x)
|
966 jim.wunderlich 1.21 {
967 Packer::unpackUint32(in, pos, x.cimFlavor);
968 }
|
969 schuur 1.1
|
970 mike 1.24 void BinaryStreamer::_packType(Buffer& out, const CIMType& x)
|
971 jim.wunderlich 1.21 {
972 Packer::packUint8(out, Uint8(x));
973 }
|
974 schuur 1.1
|
975 jim.wunderlich 1.21 void BinaryStreamer::_unpackType(
|
976 mike 1.24 const Buffer& in, Uint32& pos, CIMType& x)
|
977 jim.wunderlich 1.21 {
978 Uint8 tmp;
979 Packer::unpackUint8(in, pos, tmp);
980 x = CIMType(tmp);
981 }
|
982 schuur 1.1
|
983 jim.wunderlich 1.21 void BinaryStreamer::encode(
|
984 david.dillard 1.28 Buffer& out,
|
985 jim.wunderlich 1.21 const CIMClass& x)
986 {
987 CIMClassRep* rep = x._rep;
988 _packMagicByte(out);
989 _packHeader(out, BINARY_CLASS);
990 _packName(out, x.getClassName());
991 _packName(out, x.getSuperClassName());
992 PackQualifiers<CIMClassRep>::func(out, rep);
993 _packProperties(out, rep);
994 _packMethods(out, rep);
995 Packer::packBoolean(out, rep->_resolved);
996 }
|
997 schuur 1.1
|
998 jim.wunderlich 1.21 void BinaryStreamer::decode(
|
999 david.dillard 1.28 const Buffer& in,
1000 unsigned int pos,
|
1001 jim.wunderlich 1.21 CIMClass& x)
|
1002 schuur 1.1 {
|
1003 jim.wunderlich 1.21 _checkMagicByte(in, pos);
1004 _checkHeader(in, pos, BINARY_CLASS);
1005
1006 CIMName className;
1007 _unpackName(in, pos, className);
1008
1009 CIMName superClassName;
1010 _unpackName(in, pos, superClassName);
|
1011 schuur 1.1
|
1012 jim.wunderlich 1.21 CIMClass cimClass(className, superClassName);
|
1013 schuur 1.1
|
1014 jim.wunderlich 1.21 UnpackQualifiers<CIMClass>::func(in, pos, cimClass);
1015 UnpackProperties<CIMClass>::func(in, pos, cimClass);
1016 UnpackMethods<CIMClass>::func(in, pos, cimClass);
|
1017 schuur 1.1
|
1018 jim.wunderlich 1.21 Boolean resolved;
1019 Packer::unpackBoolean(in, pos, resolved);
1020 cimClass._rep->_resolved = resolved;
1021 x = cimClass;
1022 }
|
1023 schuur 1.1
|
1024 jim.wunderlich 1.21 void BinaryStreamer::encode(
|
1025 david.dillard 1.28 Buffer& out,
|
1026 jim.wunderlich 1.21 const CIMInstance& x)
1027 {
1028 CIMInstanceRep* rep = x._rep;
1029 _packMagicByte(out);
1030 _packHeader(out, BINARY_INSTANCE);
1031 _packObjectPath(out, x.getPath());
1032 PackQualifiers<CIMInstanceRep>::func(out, rep);
1033 _packProperties(out, rep);
1034 Packer::packBoolean(out, rep->_resolved);
1035 }
|
1036 schuur 1.1
|
1037 jim.wunderlich 1.21 void BinaryStreamer::decode(
|
1038 david.dillard 1.28 const Buffer& in,
1039 unsigned int pos,
|
1040 jim.wunderlich 1.21 CIMInstance& x)
1041 {
1042 _checkMagicByte(in, pos);
1043 _checkHeader(in, pos, BINARY_INSTANCE);
|
1044 schuur 1.1
|
1045 jim.wunderlich 1.21 CIMObjectPath objectPath;
1046 _unpackObjectPath(in, pos, objectPath);
1047 CIMInstance cimInstance(objectPath.getClassName());
1048 cimInstance.setPath(objectPath);
|
1049 schuur 1.1
|
1050 jim.wunderlich 1.21 UnpackQualifiers<CIMInstance>::func(in, pos, cimInstance);
1051 UnpackProperties<CIMInstance>::func(in, pos, cimInstance);
1052
1053 Boolean resolved;
1054 Packer::unpackBoolean(in, pos, resolved);
1055 cimInstance._rep->_resolved = resolved;
1056 x = cimInstance;
|
1057 schuur 1.1 }
1058
|
1059 jim.wunderlich 1.21 void BinaryStreamer::encode(
|
1060 david.dillard 1.28 Buffer& out,
|
1061 jim.wunderlich 1.21 const CIMQualifierDecl& x)
1062 {
1063 _packMagicByte(out);
1064 _packHeader(out, BINARY_QUALIFIER_DECL);
1065 _packName(out , x.getName());
1066 _packValue(out , x.getValue());
1067 _packScope(out , x.getScope());
1068 _packFlavor(out , x.getFlavor());
1069 Packer::packSize(out, x.getArraySize());
1070 }
|
1071 schuur 1.1
|
1072 jim.wunderlich 1.21 void BinaryStreamer::decode(
|
1073 david.dillard 1.28 const Buffer& in,
1074 unsigned int pos,
|
1075 jim.wunderlich 1.21 CIMQualifierDecl& x)
|
1076 schuur 1.1 {
|
1077 jim.wunderlich 1.21 _checkMagicByte(in, pos);
1078 _checkHeader(in, pos, BINARY_QUALIFIER_DECL);
1079
1080 CIMName qualifierName;
1081 _unpackName(in, pos, qualifierName);
1082
1083 CIMValue value;
1084 _unpackValue(in, pos, value);
1085
1086 CIMScope scope;
1087 _unpackScope(in, pos, scope);
|
1088 konrad.r 1.8
|
1089 jim.wunderlich 1.21 CIMFlavor flavor;
1090 BinaryStreamer::_unpackFlavor(in, pos, flavor);
1091
1092 Uint32 arraySize;
1093 Packer::unpackSize(in, pos, arraySize);
1094
1095 x = CIMQualifierDecl(qualifierName, value, scope, flavor, arraySize);
|
1096 schuur 1.1 }
1097
1098 PEGASUS_NAMESPACE_END
|