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

Return to BinaryStreamer.cpp CVS log

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

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

No CVS admin address has been configured