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

No CVS admin address has been configured