pegasus/src/Pegasus/Common/BinaryStreamer.cpp - annotate

Return to BinaryStreamer.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

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

No CVS admin address has been configured