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
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
253 jim.wunderlich 1.21 template<class T> 254 struct UnpackArray 255 { 256 static void func(
257 david.dillard 1.28 const Buffer& in, Uint32& pos, Uint32 n, CIMValue& value)
258 jim.wunderlich 1.21 {
259 david.dillard 1.28 Array<T> array; 260 array.reserveCapacity(n);
261 jim.wunderlich 1.21
262 david.dillard 1.28 for (Uint32 i = 0; i < n; i++) 263 { 264 T tmp; 265 _unpack(in, pos, tmp); 266 array.append(tmp); 267 }
268 jim.wunderlich 1.21
269 david.dillard 1.28 value.set(array);
270 jim.wunderlich 1.21 } 271 }; 272 273 template<class T> 274 struct UnpackScalar
275 schuur 1.1 {
276 jim.wunderlich 1.21 static void func(
277 david.dillard 1.28 const Buffer& in, Uint32& pos, CIMValue& value)
278 jim.wunderlich 1.21 {
279 david.dillard 1.28 T tmp; 280 _unpack(in, pos, tmp); 281 value.set(tmp);
282 jim.wunderlich 1.21 } 283 }; 284 285 template<class OBJECT> 286 struct UnpackQualifiers 287 {
288 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
289 jim.wunderlich 1.21 {
290 david.dillard 1.28 Uint32 n; 291 Packer::unpackSize(in, pos, n);
292 jim.wunderlich 1.21
293 david.dillard 1.28 CIMQualifier q;
294 jim.wunderlich 1.21
295 david.dillard 1.28 for (size_t i = 0; i < n; i++) 296 { 297 BinaryStreamer::_unpackQualifier(in, pos, q); 298 x.addQualifier(q); 299 }
300 jim.wunderlich 1.21 } 301 }; 302 303 template<class REP> 304 struct PackQualifiers 305 {
306 mike 1.24 static void func(Buffer& out, REP* rep)
307 jim.wunderlich 1.21 {
308 david.dillard 1.28 Uint32 n = rep->getQualifierCount(); 309 Packer::packSize(out, n);
310 jim.wunderlich 1.21
311 david.dillard 1.28 for (Uint32 i = 0; i < n; i++) 312 BinaryStreamer::_packQualifier(out, rep->getQualifier(i));
313 jim.wunderlich 1.21 } 314 }; 315 316 template<class OBJECT> 317 struct UnpackProperties 318 {
319 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
320 jim.wunderlich 1.21 {
321 david.dillard 1.28 Uint32 n; 322 Packer::unpackSize(in, pos, n);
323 jim.wunderlich 1.21
324 david.dillard 1.28 CIMProperty p;
325 jim.wunderlich 1.21
326 david.dillard 1.28 for (size_t i = 0; i < n; i++) 327 { 328 BinaryStreamer::_unpackProperty(in, pos, p); 329 x.addProperty(p); 330 }
331 jim.wunderlich 1.21 } 332 }; 333 334 template<class OBJECT> 335 struct UnpackMethods 336 {
337 mike 1.24 static void func(const Buffer& in, Uint32& pos, OBJECT& x)
338 jim.wunderlich 1.21 {
339 david.dillard 1.28 Uint32 n; 340 Packer::unpackSize(in, pos, n);
341 jim.wunderlich 1.21
342 david.dillard 1.28 CIMMethod m;
343 jim.wunderlich 1.21
344 david.dillard 1.28 for (size_t i = 0; i < n; i++) 345 { 346 BinaryStreamer::_unpackMethod(in, pos, m); 347 x.addMethod(m); 348 }
349 jim.wunderlich 1.21 } 350 }; 351
352 mike 1.24 void BinaryStreamer::_packName(Buffer& out, const CIMName& x)
353 jim.wunderlich 1.21 { 354 Packer::packString(out, x.getString());
355 schuur 1.1 } 356
357 jim.wunderlich 1.21 void BinaryStreamer::_unpackName(
358 mike 1.24 const Buffer& in, Uint32& pos, CIMName& x)
359 schuur 1.1 {
360 jim.wunderlich 1.21 String tmp; 361 Packer::unpackString(in, pos, tmp);
362 r.kieninger 1.27 x = tmp.size() ? CIMNameUnchecked(tmp) : CIMName();
363 schuur 1.1 } 364
365 mike 1.24 void BinaryStreamer::_packQualifier(Buffer& out, const CIMQualifier& x)
366 schuur 1.1 {
367 jim.wunderlich 1.21 CIMQualifierRep* rep = x._rep; 368 369 _packMagicByte(out); 370 _packName(out, rep->getName()); 371 _packValue(out, rep->getValue()); 372 _packFlavor(out, rep->getFlavor()); 373 Packer::packBoolean(out, rep->getPropagated());
374 schuur 1.1 } 375
376 jim.wunderlich 1.21 void BinaryStreamer::_unpackQualifier(
377 mike 1.24 const Buffer& in, Uint32& pos, CIMQualifier& x)
378 schuur 1.1 {
379 jim.wunderlich 1.21 _checkMagicByte(in, pos); 380 381 CIMName name; 382 _unpackName(in, pos, name); 383 384 CIMValue value; 385 _unpackValue(in, pos, value); 386 387 CIMFlavor flavor; 388 BinaryStreamer::_unpackFlavor(in, pos, flavor); 389 390 Boolean propagated; 391 Packer::unpackBoolean(in, pos, propagated); 392 393 x = CIMQualifier(name, value, flavor, propagated);
394 schuur 1.1 } 395
396 mike 1.24 void BinaryStreamer::_packValue(Buffer& out, const CIMValue& x)
397 jim.wunderlich 1.21 { 398 CIMValueRep* rep = x._rep; 399 400 _packMagicByte(out); 401 _packType(out, x.getType()); 402 Packer::packBoolean(out, x.isArray()); 403 404 Uint32 n = x.getArraySize();
405 schuur 1.1
406 jim.wunderlich 1.21 if (x.isArray())
407 david.dillard 1.28 Packer::packSize(out, n);
408 schuur 1.1
409 jim.wunderlich 1.21 Packer::packBoolean(out, x.isNull());
410 schuur 1.1
411 jim.wunderlich 1.21 if (x.isNull())
412 david.dillard 1.28 return;
413 jim.wunderlich 1.21 414 if (x.isArray()) 415 {
416 david.dillard 1.28 switch (x.getType()) 417 { 418 case CIMTYPE_BOOLEAN: 419 Packer::packBoolean( 420 out, CIMValueType<Boolean>::aref(rep).getData(), n); 421 break; 422 423 case CIMTYPE_SINT8: 424 case CIMTYPE_UINT8: 425 Packer::packUint8( 426 out, CIMValueType<Uint8>::aref(rep).getData(), n); 427 break; 428 429 case CIMTYPE_SINT16: 430 case CIMTYPE_UINT16: 431 case CIMTYPE_CHAR16: 432 Packer::packUint16( 433 out, CIMValueType<Uint16>::aref(rep).getData(), n); 434 break; 435 436 case CIMTYPE_SINT32: 437 david.dillard 1.28 case CIMTYPE_UINT32: 438 case CIMTYPE_REAL32: 439 Packer::packUint32( 440 out, CIMValueType<Uint32>::aref(rep).getData(), n); 441 break; 442 443 case CIMTYPE_SINT64: 444 case CIMTYPE_UINT64: 445 case CIMTYPE_REAL64: 446 Packer::packUint64( 447 out, CIMValueType<Uint64>::aref(rep).getData(), n); 448 break; 449 450 case CIMTYPE_STRING: 451 Packer::packString(out, 452 CIMValueType<String>::aref(rep).getData(), n); 453 break; 454 455 case CIMTYPE_DATETIME: 456 { 457 const Array<CIMDateTime>& a = 458 david.dillard 1.28 CIMValueType<CIMDateTime>::aref(rep); 459 460 for (Uint32 i = 0; i < n; i++) 461 Packer::packString(out, a[i].toString()); 462 break; 463 } 464 465 case CIMTYPE_REFERENCE: 466 { 467 const Array<CIMObjectPath>& a = 468 CIMValueType<CIMObjectPath>::aref(rep); 469 470 for (Uint32 i = 0; i < n; i++) 471 Packer::packString(out, a[i].toString()); 472 break; 473 } 474 475 case CIMTYPE_OBJECT:
476 dave.sudlik 1.29 { 477 const Array<CIMObject>& a = 478 CIMValueType<CIMObject>::aref(rep); 479 480 for (Uint32 i = 0; i < n; i++) 481 Packer::packString(out, a[i].toString());
482 david.dillard 1.28 break;
483 dave.sudlik 1.29 }
484 a.dunfey 1.32 485 case CIMTYPE_INSTANCE: 486 { 487 const Array<CIMInstance>& a = 488 CIMValueType<CIMInstance>::aref(rep); 489 490 for (Uint32 i = 0; i < n; i++) 491 { 492 CIMObject tmp(a[i]); 493 Packer::packString(out, tmp.toString()); 494 } 495 break; 496 }
497 david.dillard 1.28 }
498 jim.wunderlich 1.21 } 499 else 500 {
501 david.dillard 1.28 switch (x.getType()) 502 { 503 case CIMTYPE_BOOLEAN: 504 Packer::packBoolean(out, rep->u._booleanValue); 505 break; 506 507 case CIMTYPE_SINT8: 508 case CIMTYPE_UINT8: 509 Packer::packUint8(out, rep->u._uint8Value); 510 break; 511 512 case CIMTYPE_SINT16: 513 case CIMTYPE_UINT16: 514 case CIMTYPE_CHAR16: 515 Packer::packUint16(out, rep->u._uint16Value); 516 break; 517 518 case CIMTYPE_SINT32: 519 case CIMTYPE_UINT32: 520 case CIMTYPE_REAL32: 521 Packer::packUint32(out, rep->u._uint32Value); 522 david.dillard 1.28 break; 523 524 case CIMTYPE_SINT64: 525 case CIMTYPE_UINT64: 526 case CIMTYPE_REAL64: 527 Packer::packUint64(out, rep->u._uint64Value); 528 break; 529 530 case CIMTYPE_STRING: 531 Packer::packString(out, CIMValueType<String>::ref(rep)); 532 break; 533 534 case CIMTYPE_DATETIME: 535 Packer::packString( 536 out, CIMValueType<CIMDateTime>::ref(rep).toString()); 537 break; 538 539 case CIMTYPE_REFERENCE: 540 Packer::packString( 541 out, CIMValueType<CIMObjectPath>::ref(rep).toString()); 542 break; 543 david.dillard 1.28 544 case CIMTYPE_OBJECT:
545 dave.sudlik 1.29 Packer::packString( 546 out, CIMValueType<CIMObject>::ref(rep).toString());
547 david.dillard 1.28 break;
548 a.dunfey 1.32 case CIMTYPE_INSTANCE: 549 { 550 CIMObject tmp(CIMValueType<CIMInstance>::ref(rep)); 551 Packer::packString( 552 out, tmp.toString()); 553 break; 554 }
555 david.dillard 1.28 }
556 jim.wunderlich 1.21 }
557 schuur 1.1 } 558
559 jim.wunderlich 1.21 void BinaryStreamer::_unpackValue(
560 mike 1.24 const Buffer& in, Uint32& pos, CIMValue& x)
561 jim.wunderlich 1.21 { 562 _checkMagicByte(in, pos); 563 564 CIMType type; 565 _unpackType(in, pos, type); 566 567 Boolean isArray; 568 Packer::unpackBoolean(in, pos, isArray);
569 schuur 1.1
570 jim.wunderlich 1.23 Uint32 arraySize = 0;
571 konrad.r 1.8
572 jim.wunderlich 1.21 if (isArray)
573 david.dillard 1.28 Packer::unpackSize(in, pos, arraySize);
574 schuur 1.1
575 jim.wunderlich 1.21 Boolean isNull; 576 Packer::unpackBoolean(in, pos, isNull);
577 schuur 1.1
578 jim.wunderlich 1.21 if (isNull) 579 {
580 david.dillard 1.28 x = CIMValue(type, isArray, arraySize); 581 return;
582 jim.wunderlich 1.21 }
583 schuur 1.1
584 jim.wunderlich 1.21 if (isArray) 585 {
586 david.dillard 1.28 CIMValue cimValue(type, isArray, arraySize);
587 jim.wunderlich 1.21
588 david.dillard 1.28 switch (type) 589 { 590 case CIMTYPE_BOOLEAN: 591 UnpackArray<Boolean>::func(in, pos, arraySize, cimValue); 592 break; 593 594 case CIMTYPE_UINT8: 595 UnpackArray<Uint8>::func(in, pos, arraySize, cimValue); 596 break; 597 598 case CIMTYPE_SINT8: 599 UnpackArray<Sint8>::func(in, pos, arraySize, cimValue); 600 break; 601 602 case CIMTYPE_UINT16: 603 UnpackArray<Uint16>::func(in, pos, arraySize, cimValue); 604 break; 605 606 case CIMTYPE_SINT16: 607 UnpackArray<Sint16>::func(in, pos, arraySize, cimValue); 608 break; 609 david.dillard 1.28 610 case CIMTYPE_UINT32: 611 UnpackArray<Uint32>::func(in, pos, arraySize, cimValue); 612 break; 613 614 case CIMTYPE_SINT32: 615 UnpackArray<Sint32>::func(in, pos, arraySize, cimValue); 616 break; 617 618 case CIMTYPE_UINT64: 619 UnpackArray<Uint64>::func(in, pos, arraySize, cimValue); 620 break; 621 622 case CIMTYPE_SINT64: 623 UnpackArray<Sint64>::func(in, pos, arraySize, cimValue); 624 break; 625 626 case CIMTYPE_REAL32: 627 UnpackArray<Real32>::func(in, pos, arraySize, cimValue); 628 break; 629 630 david.dillard 1.28 case CIMTYPE_REAL64: 631 UnpackArray<Real64>::func(in, pos, arraySize, cimValue); 632 break; 633 634 case CIMTYPE_CHAR16: 635 UnpackArray<Char16>::func(in, pos, arraySize, cimValue); 636 break; 637 638 case CIMTYPE_STRING: 639 UnpackArray<String>::func(in, pos, arraySize, cimValue); 640 break; 641 642 case CIMTYPE_DATETIME: 643 UnpackArray<CIMDateTime>::func(in, pos, arraySize, cimValue); 644 break; 645 646 case CIMTYPE_REFERENCE: 647 UnpackArray<CIMObjectPath>::func(in, pos, arraySize, cimValue); 648 break; 649 650 case CIMTYPE_OBJECT:
651 dave.sudlik 1.29 UnpackArray<CIMObject>::func(in, pos, arraySize, cimValue);
652 david.dillard 1.28 break;
653 a.dunfey 1.32 case CIMTYPE_INSTANCE: 654 UnpackArray<CIMInstance>::func(in, pos, arraySize, cimValue); 655 break;
656 david.dillard 1.28 }
657 schuur 1.1
658 david.dillard 1.28 x = cimValue;
659 jim.wunderlich 1.21 } 660 else 661 {
662 david.dillard 1.28 CIMValue cimValue(type, isArray);
663 jim.wunderlich 1.21
664 david.dillard 1.28 switch (type) 665 { 666 case CIMTYPE_BOOLEAN: 667 UnpackScalar<Boolean>::func(in, pos, cimValue); 668 break; 669 670 case CIMTYPE_UINT8: 671 UnpackScalar<Uint8>::func(in, pos, cimValue); 672 break; 673 674 case CIMTYPE_SINT8: 675 UnpackScalar<Sint8>::func(in, pos, cimValue); 676 break; 677 678 case CIMTYPE_UINT16: 679 UnpackScalar<Uint16>::func(in, pos, cimValue); 680 break; 681 682 case CIMTYPE_SINT16: 683 UnpackScalar<Sint16>::func(in, pos, cimValue); 684 break; 685 david.dillard 1.28 686 case CIMTYPE_UINT32: 687 UnpackScalar<Uint32>::func(in, pos, cimValue); 688 break; 689 690 case CIMTYPE_SINT32: 691 UnpackScalar<Sint32>::func(in, pos, cimValue); 692 break; 693 694 case CIMTYPE_UINT64: 695 UnpackScalar<Uint64>::func(in, pos, cimValue); 696 break; 697 698 case CIMTYPE_SINT64: 699 UnpackScalar<Sint64>::func(in, pos, cimValue); 700 break; 701 702 case CIMTYPE_REAL32: 703 UnpackScalar<Real32>::func(in, pos, cimValue); 704 break; 705 706 david.dillard 1.28 case CIMTYPE_REAL64: 707 UnpackScalar<Real64>::func(in, pos, cimValue); 708 break; 709 710 case CIMTYPE_CHAR16: 711 UnpackScalar<Char16>::func(in, pos, cimValue); 712 break; 713 714 case CIMTYPE_STRING: 715 UnpackScalar<String>::func(in, pos, cimValue); 716 break; 717 718 case CIMTYPE_DATETIME: 719 UnpackScalar<CIMDateTime>::func(in, pos, cimValue); 720 break; 721 722 case CIMTYPE_REFERENCE: 723 UnpackScalar<CIMObjectPath>::func(in, pos, cimValue); 724 break; 725 726 case CIMTYPE_OBJECT:
727 dave.sudlik 1.29 UnpackScalar<CIMObject>::func(in, pos, cimValue);
728 david.dillard 1.28 break;
729 a.dunfey 1.32 case CIMTYPE_INSTANCE: 730 UnpackScalar<CIMInstance>::func(in, pos, cimValue); 731 break;
732 david.dillard 1.28 }
733 schuur 1.1
734 david.dillard 1.28 x = cimValue;
735 jim.wunderlich 1.21 }
736 schuur 1.1
737 jim.wunderlich 1.21 return; 738 }
739 schuur 1.1
740 mike 1.24 void BinaryStreamer::_packProperty(Buffer& out, const CIMProperty& x)
741 jim.wunderlich 1.21 { 742 CIMPropertyRep* rep = x._rep;
743 schuur 1.1
744 jim.wunderlich 1.21 _packMagicByte(out); 745 _packName(out, rep->getName()); 746 _packValue(out, rep->getValue()); 747 Packer::packSize(out, rep->getArraySize()); 748 _packName(out, rep->getReferenceClassName()); 749 _packName(out, rep->getClassOrigin()); 750 Packer::packBoolean(out, rep->getPropagated()); 751 PackQualifiers<CIMPropertyRep>::func(out, rep);
752 schuur 1.1 } 753
754 jim.wunderlich 1.21 void BinaryStreamer::_unpackProperty(
755 mike 1.24 const Buffer& in, Uint32& pos, CIMProperty& x)
756 jim.wunderlich 1.21 { 757 _checkMagicByte(in, pos);
758 schuur 1.1
759 jim.wunderlich 1.21 CIMName name; 760 _unpackName(in, pos, name);
761 schuur 1.1
762 jim.wunderlich 1.21 CIMValue value; 763 _unpackValue(in, pos, value);
764 schuur 1.1
765 jim.wunderlich 1.21 Uint32 arraySize; 766 Packer::unpackSize(in, pos, arraySize);
767 schuur 1.1
768 jim.wunderlich 1.21 CIMName referenceClassName; 769 _unpackName(in, pos, referenceClassName);
770 schuur 1.1
771 jim.wunderlich 1.21 CIMName classOrigin; 772 _unpackName(in, pos, classOrigin);
773 schuur 1.1
774 jim.wunderlich 1.21 Boolean propagated; 775 Packer::unpackBoolean(in, pos, propagated);
776 schuur 1.1
777 jim.wunderlich 1.21 CIMProperty cimProperty(
778 david.dillard 1.28 name, value, arraySize, referenceClassName, classOrigin, propagated);
779 schuur 1.1
780 jim.wunderlich 1.21 UnpackQualifiers<CIMProperty>::func(in, pos, cimProperty);
781 schuur 1.1
782 a.dunfey 1.32 if(cimProperty.getType() == CIMTYPE_STRING) 783 { 784 CIMType realType = CIMTYPE_STRING; 785 if(cimProperty.findQualifier("EmbeddedInstance") != PEG_NOT_FOUND) 786 { 787 // Note that this condition should only happen for properties in 788 // class definitions, and only NULL values are recognized. We 789 // currently don't handle embedded instance types with default 790 // values in the class definition. 791 PEGASUS_ASSERT(value.isNull()); 792 realType = CIMTYPE_INSTANCE; 793 } 794 else if(cimProperty.findQualifier("EmbeddedObject") != PEG_NOT_FOUND) 795 { 796 // Note that this condition should only happen for properties in 797 // class definitions, and only NULL values are recognized. We 798 // currently don't handle embedded object types with default 799 // values in the class definition. 800 PEGASUS_ASSERT(value.isNull()); 801 realType = CIMTYPE_OBJECT; 802 } 803 a.dunfey 1.32 804 if(realType != CIMTYPE_STRING) 805 { 806 CIMProperty tmpProperty(name, CIMValue(realType, value.isArray()), 807 arraySize, referenceClassName, classOrigin, propagated); 808 for(unsigned int i = 0, n = cimProperty.getQualifierCount(); 809 i < n; ++i) 810 { 811 tmpProperty.addQualifier(cimProperty.getQualifier(i)); 812 } 813 cimProperty = tmpProperty; 814 } 815 } 816
817 jim.wunderlich 1.21 x = cimProperty;
818 schuur 1.1 } 819
820 mike 1.24 void BinaryStreamer::_packParameter(Buffer& out, const CIMParameter& x)
821 jim.wunderlich 1.21 { 822 CIMParameterRep* rep = x._rep;
823 schuur 1.1
824 jim.wunderlich 1.21 _packMagicByte(out); 825 _packName(out, rep->getName()); 826 _packType(out, rep->getType()); 827 Packer::packBoolean(out, rep->isArray()); 828 Packer::packSize(out, rep->getArraySize()); 829 _packName(out, rep->getReferenceClassName()); 830 PackQualifiers<CIMParameterRep>::func(out, rep); 831 } 832 833 void BinaryStreamer::_unpackParameter(
834 mike 1.24 const Buffer& in, Uint32& pos, CIMParameter& x)
835 schuur 1.1 {
836 jim.wunderlich 1.21 _checkMagicByte(in, pos);
837 konrad.r 1.8
838 jim.wunderlich 1.21 CIMName name; 839 _unpackName(in, pos, name);
840 konrad.r 1.8
841 jim.wunderlich 1.21 CIMType type; 842 _unpackType(in, pos, type);
843 schuur 1.1
844 jim.wunderlich 1.21 Boolean isArray; 845 Packer::unpackBoolean(in, pos, isArray);
846 schuur 1.1
847 jim.wunderlich 1.21 Uint32 arraySize; 848 Packer::unpackSize(in, pos, arraySize);
849 schuur 1.1
850 jim.wunderlich 1.21 CIMName referenceClassName; 851 _unpackName(in, pos, referenceClassName);
852 schuur 1.1
853 jim.wunderlich 1.21 CIMParameter cimParameter(
854 david.dillard 1.28 name, type, isArray, arraySize, referenceClassName);
855 schuur 1.1
856 jim.wunderlich 1.21 UnpackQualifiers<CIMParameter>::func(in, pos, cimParameter);
857 schuur 1.1
858 jim.wunderlich 1.21 x = cimParameter; 859 }
860 schuur 1.1
861 mike 1.24 void BinaryStreamer::_packParameters(Buffer& out, CIMMethodRep* rep)
862 jim.wunderlich 1.21 { 863 Uint32 n = rep->getParameterCount(); 864 Packer::packSize(out, n);
865 schuur 1.1
866 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
867 david.dillard 1.28 BinaryStreamer::_packParameter(out, rep->getParameter(i));
868 schuur 1.1 } 869
870 jim.wunderlich 1.21 void BinaryStreamer::_unpackParameters(
871 mike 1.24 const Buffer& in, Uint32& pos, CIMMethod& x)
872 jim.wunderlich 1.21 { 873 Uint32 n; 874 Packer::unpackSize(in, pos, n);
875 schuur 1.1
876 jim.wunderlich 1.21 for (size_t i = 0; i < n; i++) 877 {
878 david.dillard 1.28 CIMParameter q; 879 _unpackParameter(in, pos, q); 880 x.addParameter(q);
881 jim.wunderlich 1.21 } 882 }
883 schuur 1.1
884 mike 1.24 void BinaryStreamer::_packMethod(Buffer& out, const CIMMethod& x)
885 jim.wunderlich 1.21 { 886 CIMMethodRep* rep = x._rep;
887 schuur 1.1
888 jim.wunderlich 1.21 _packMagicByte(out); 889 _packName(out, rep->getName()); 890 _packType(out, rep->getType()); 891 _packName(out, rep->getClassOrigin()); 892 Packer::packBoolean(out, rep->getPropagated()); 893 PackQualifiers<CIMMethodRep>::func(out, rep); 894 _packParameters(out, rep); 895 }
896 schuur 1.1
897 jim.wunderlich 1.21 void BinaryStreamer::_unpackMethod(
898 mike 1.24 const Buffer& in, Uint32& pos, CIMMethod& x)
899 schuur 1.1 {
900 jim.wunderlich 1.21 _checkMagicByte(in, pos);
901 schuur 1.1
902 jim.wunderlich 1.21 CIMName name; 903 _unpackName(in, pos, name);
904 schuur 1.1
905 jim.wunderlich 1.21 CIMType type; 906 _unpackType(in, pos, type);
907 schuur 1.1
908 jim.wunderlich 1.21 CIMName classOrigin; 909 _unpackName(in, pos, classOrigin);
910 schuur 1.1
911 jim.wunderlich 1.21 Boolean propagated; 912 Packer::unpackBoolean(in, pos, propagated);
913 schuur 1.1
914 jim.wunderlich 1.21 CIMMethod cimMethod(name, type, classOrigin, propagated); 915 UnpackQualifiers<CIMMethod>::func(in, pos, cimMethod); 916 _unpackParameters(in, pos, cimMethod);
917 schuur 1.1
918 jim.wunderlich 1.21 x = cimMethod;
919 schuur 1.1 } 920
921 mike 1.24 void BinaryStreamer::_packObjectPath(Buffer& out, const CIMObjectPath& x)
922 jim.wunderlich 1.21 { 923 Packer::packString(out, x.toString()); 924 }
925 schuur 1.1
926 jim.wunderlich 1.21 void BinaryStreamer::_unpackObjectPath(
927 mike 1.24 const Buffer& in, Uint32& pos, CIMObjectPath& x)
928 schuur 1.1 {
929 jim.wunderlich 1.21 String tmp; 930 Packer::unpackString(in, pos, tmp); 931 x = CIMObjectPath(tmp); 932 }
933 konrad.r 1.8
934 mike 1.24 void BinaryStreamer::_packProperties(Buffer& out, CIMObjectRep* rep)
935 jim.wunderlich 1.21 { 936 Uint32 n = rep->getPropertyCount(); 937 Packer::packSize(out, n);
938 schuur 1.1
939 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
940 david.dillard 1.28 BinaryStreamer::_packProperty(out, rep->getProperty(i));
941 jim.wunderlich 1.21 }
942 schuur 1.1
943 mike 1.24 void BinaryStreamer::_packMethods(Buffer& out, CIMClassRep* rep)
944 jim.wunderlich 1.21 { 945 Uint32 n = rep->getMethodCount(); 946 Packer::packSize(out, n);
947 schuur 1.1
948 jim.wunderlich 1.21 for (Uint32 i = 0; i < n; i++)
949 david.dillard 1.28 BinaryStreamer::_packMethod(out, rep->getMethod(i));
950 jim.wunderlich 1.21 }
951 schuur 1.1
952 mike 1.24 void BinaryStreamer::_packScope(Buffer& out, const CIMScope& x)
953 jim.wunderlich 1.21 { 954 Packer::packUint32(out, x.cimScope); 955 }
956 schuur 1.1
957 jim.wunderlich 1.21 void BinaryStreamer::_unpackScope(
958 mike 1.24 const Buffer& in, Uint32& pos, CIMScope& x)
959 jim.wunderlich 1.21 { 960 Packer::unpackUint32(in, pos, x.cimScope); 961 }
962 schuur 1.1
963 mike 1.24 void BinaryStreamer::_packFlavor(Buffer& out, const CIMFlavor& x)
964 jim.wunderlich 1.21 { 965 Packer::packUint32(out, x.cimFlavor);
966 schuur 1.1 } 967
968 jim.wunderlich 1.21 void BinaryStreamer::_unpackFlavor(
969 mike 1.24 const Buffer& in, Uint32& pos, CIMFlavor& x)
970 jim.wunderlich 1.21 { 971 Packer::unpackUint32(in, pos, x.cimFlavor); 972 }
973 schuur 1.1
974 mike 1.24 void BinaryStreamer::_packType(Buffer& out, const CIMType& x)
975 jim.wunderlich 1.21 { 976 Packer::packUint8(out, Uint8(x)); 977 }
978 schuur 1.1
979 jim.wunderlich 1.21 void BinaryStreamer::_unpackType(
980 mike 1.24 const Buffer& in, Uint32& pos, CIMType& x)
981 jim.wunderlich 1.21 { 982 Uint8 tmp; 983 Packer::unpackUint8(in, pos, tmp); 984 x = CIMType(tmp); 985 }
986 schuur 1.1
987 jim.wunderlich 1.21 void BinaryStreamer::encode(
988 david.dillard 1.28 Buffer& out,
989 jim.wunderlich 1.21 const CIMClass& x) 990 { 991 CIMClassRep* rep = x._rep; 992 _packMagicByte(out); 993 _packHeader(out, BINARY_CLASS); 994 _packName(out, x.getClassName()); 995 _packName(out, x.getSuperClassName()); 996 PackQualifiers<CIMClassRep>::func(out, rep); 997 _packProperties(out, rep); 998 _packMethods(out, rep); 999 Packer::packBoolean(out, rep->_resolved); 1000 }
1001 schuur 1.1
1002 jim.wunderlich 1.21 void BinaryStreamer::decode(
1003 david.dillard 1.28 const Buffer& in, 1004 unsigned int pos,
1005 jim.wunderlich 1.21 CIMClass& x)
1006 schuur 1.1 {
1007 jim.wunderlich 1.21 _checkMagicByte(in, pos); 1008 _checkHeader(in, pos, BINARY_CLASS); 1009 1010 CIMName className; 1011 _unpackName(in, pos, className); 1012 1013 CIMName superClassName; 1014 _unpackName(in, pos, superClassName);
1015 schuur 1.1
1016 jim.wunderlich 1.21 CIMClass cimClass(className, superClassName);
1017 schuur 1.1
1018 jim.wunderlich 1.21 UnpackQualifiers<CIMClass>::func(in, pos, cimClass); 1019 UnpackProperties<CIMClass>::func(in, pos, cimClass); 1020 UnpackMethods<CIMClass>::func(in, pos, cimClass);
1021 schuur 1.1
1022 jim.wunderlich 1.21 Boolean resolved; 1023 Packer::unpackBoolean(in, pos, resolved); 1024 cimClass._rep->_resolved = resolved; 1025 x = cimClass; 1026 }
1027 schuur 1.1
1028 jim.wunderlich 1.21 void BinaryStreamer::encode(
1029 david.dillard 1.28 Buffer& out,
1030 jim.wunderlich 1.21 const CIMInstance& x) 1031 { 1032 CIMInstanceRep* rep = x._rep; 1033 _packMagicByte(out); 1034 _packHeader(out, BINARY_INSTANCE); 1035 _packObjectPath(out, x.getPath()); 1036 PackQualifiers<CIMInstanceRep>::func(out, rep); 1037 _packProperties(out, rep); 1038 Packer::packBoolean(out, rep->_resolved); 1039 }
1040 schuur 1.1
1041 jim.wunderlich 1.21 void BinaryStreamer::decode(
1042 david.dillard 1.28 const Buffer& in, 1043 unsigned int pos,
1044 jim.wunderlich 1.21 CIMInstance& x) 1045 { 1046 _checkMagicByte(in, pos); 1047 _checkHeader(in, pos, BINARY_INSTANCE);
1048 schuur 1.1
1049 jim.wunderlich 1.21 CIMObjectPath objectPath; 1050 _unpackObjectPath(in, pos, objectPath); 1051 CIMInstance cimInstance(objectPath.getClassName()); 1052 cimInstance.setPath(objectPath);
1053 schuur 1.1
1054 jim.wunderlich 1.21 UnpackQualifiers<CIMInstance>::func(in, pos, cimInstance); 1055 UnpackProperties<CIMInstance>::func(in, pos, cimInstance); 1056 1057 Boolean resolved; 1058 Packer::unpackBoolean(in, pos, resolved); 1059 cimInstance._rep->_resolved = resolved; 1060 x = cimInstance;
1061 schuur 1.1 } 1062
1063 jim.wunderlich 1.21 void BinaryStreamer::encode(
1064 david.dillard 1.28 Buffer& out,
1065 jim.wunderlich 1.21 const CIMQualifierDecl& x) 1066 { 1067 _packMagicByte(out); 1068 _packHeader(out, BINARY_QUALIFIER_DECL); 1069 _packName(out , x.getName()); 1070 _packValue(out , x.getValue()); 1071 _packScope(out , x.getScope()); 1072 _packFlavor(out , x.getFlavor()); 1073 Packer::packSize(out, x.getArraySize()); 1074 }
1075 schuur 1.1
1076 jim.wunderlich 1.21 void BinaryStreamer::decode(
1077 david.dillard 1.28 const Buffer& in, 1078 unsigned int pos,
1079 jim.wunderlich 1.21 CIMQualifierDecl& x)
1080 schuur 1.1 {
1081 jim.wunderlich 1.21 _checkMagicByte(in, pos); 1082 _checkHeader(in, pos, BINARY_QUALIFIER_DECL); 1083 1084 CIMName qualifierName; 1085 _unpackName(in, pos, qualifierName); 1086 1087 CIMValue value; 1088 _unpackValue(in, pos, value); 1089 1090 CIMScope scope; 1091 _unpackScope(in, pos, scope);
1092 konrad.r 1.8
1093 jim.wunderlich 1.21 CIMFlavor flavor; 1094 BinaryStreamer::_unpackFlavor(in, pos, flavor); 1095 1096 Uint32 arraySize; 1097 Packer::unpackSize(in, pos, arraySize); 1098 1099 x = CIMQualifierDecl(qualifierName, value, scope, flavor, arraySize);
1100 schuur 1.1 } 1101 1102 PEGASUS_NAMESPACE_END

No CVS admin address has been configured