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 dave.sudlik 1.2 // Modified By: Dave Sudlik (dsudlik@us.ibm.com)
33 david.dillard 1.10 // David Dillard, VERITAS Software Corp. 34 // (david.dillard@veritas.com)
35 schuur 1.1 // 36 //%///////////////////////////////////////////////////////////////////////////// 37 38 #include "XmlWriter.h" 39 #include "XmlReader.h" 40 #include "XmlParser.h" 41 42 #include "CIMName.h" 43 #include "BinaryStreamer.h" 44 #include "CIMClassRep.h" 45 #include "CIMInstanceRep.h" 46 #include "CIMMethodRep.h" 47 #include "CIMParameterRep.h" 48 #include "CIMPropertyRep.h" 49 #include "CIMQualifierRep.h" 50 51 #include "CIMValue.h" 52 #include "CIMValueRep.h" 53 54 PEGASUS_USING_STD; 55 56 schuur 1.1 PEGASUS_NAMESPACE_BEGIN 57
58 konrad.r 1.8 #if defined(PEGASUS_OS_HPUX) 59 #define TYPE_CONV 60 #endif 61
62 david.dillard 1.10 void BinaryStreamer::encode(Array<char>& out, const CIMClass& cls)
63 schuur 1.1 { 64 toBin(out, cls); 65 } 66
67 david.dillard 1.10 void BinaryStreamer::encode(Array<char>& out, const CIMInstance& inst)
68 schuur 1.1 { 69 toBin(out, inst); 70 } 71
72 david.dillard 1.10 void BinaryStreamer::encode(Array<char>& out, const CIMQualifierDecl& qual)
73 schuur 1.1 { 74 toBin(out, qual); 75 } 76
77 david.dillard 1.10 void BinaryStreamer::decode(const Array<char>& in, unsigned int pos, CIMClass& cls)
78 schuur 1.1 { 79 cls=extractClass(in,pos,""); 80 } 81
82 david.dillard 1.10 void BinaryStreamer::decode(const Array<char>& in, unsigned int pos, CIMInstance& inst)
83 schuur 1.1 { 84 inst=extractInstance(in,pos,""); 85 } 86
87 david.dillard 1.10 void BinaryStreamer::decode(const Array<char>& in, unsigned int pos, CIMQualifierDecl& qual)
88 schuur 1.1 { 89 qual=extractQualifierDecl(in,pos,""); 90 } 91 92 93
94 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, const CIMObjectPath &op)
95 schuur 1.1 { 96 CString ustr=op.toString().getCString(); 97 Uint16 nl=strlen((const char*)ustr);
98 david.dillard 1.10 out.append((char)&nl,sizeof(Uint16)); 99 out.append((char)((const char*)ustr),nl);
100 schuur 1.1 } 101
102 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, const CIMName &cn)
103 schuur 1.1 { 104 CString ustr=cn.getString().getCString(); 105 Uint16 nl=strlen((const char*)ustr);
106 david.dillard 1.10 out.append((char*)&nl,sizeof(Sint16));
107 schuur 1.1 if (nl)
108 david.dillard 1.10 out.append((char)((const char)ustr),nl);
109 schuur 1.1 } 110
111 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, const CIMType &typ)
112 schuur 1.1 { 113 Uint16 type=(Uint16)typ;
114 david.dillard 1.10 out.append((char*)&type,sizeof(Uint16));
115 schuur 1.1 } 116
117 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, Uint16 ui)
118 schuur 1.1 {
119 david.dillard 1.10 out.append((char*)&ui,sizeof(Uint16));
120 schuur 1.1 } 121
122 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, Uint32 ui)
123 schuur 1.1 {
124 david.dillard 1.10 out.append((char*)&ui,sizeof(Uint32));
125 schuur 1.1 } 126
127 david.dillard 1.10 void BinaryStreamer::append(Array<char>& out, Boolean b)
128 schuur 1.1 {
129 jim.wunderlich 1.18 out.append((char*) &b,sizeof(Boolean));
130 schuur 1.1 } 131 132 133
134 david.dillard 1.10 CIMObjectPath BinaryStreamer::extractObjectPath(const char *ar, Uint32 & pos)
135 schuur 1.1 {
136 konrad.r 1.5 Uint16 sl; //=(Uint16)(ar+pos); 137 memcpy( &sl, ar + pos, sizeof (Uint16));
138 schuur 1.1 Uint32 ppos=pos+=sizeof(Uint16);
139 konrad.r 1.5
140 schuur 1.1 pos+=sl; 141 return CIMObjectPath(String(((char*)(ar+ppos)),sl)); 142 } 143
144 david.dillard 1.10 CIMName BinaryStreamer::extractName(const char *ar, Uint32 & pos)
145 schuur 1.1 {
146 konrad.r 1.5 Uint16 sl; //=(Uint16)(ar+pos); 147 memcpy(&sl, ar + pos, sizeof (Uint16));
148 schuur 1.1 Uint32 ppos=pos+=sizeof(Uint16); 149 if (sl) { 150 pos+=sl; 151 return CIMName(String(((char*)(ar+ppos)),sl)); 152 } 153 return CIMName(); 154 } 155
156 david.dillard 1.10 Uint16 BinaryStreamer::extractUint16(const char *ar, Uint32 & pos)
157 schuur 1.1 {
158 konrad.r 1.5 Uint16 ui; //=(Uint16)(ar+pos); 159 memcpy (&ui, ar + pos, sizeof (Uint16));
160 schuur 1.1 pos+=sizeof(Uint16); 161 return ui; 162 } 163
164 david.dillard 1.10 CIMType BinaryStreamer::extractType(const char *ar, Uint32 & pos)
165 schuur 1.1 {
166 konrad.r 1.5 Uint16 ui; //=(Uint16)(ar+pos); 167 memcpy( &ui, ar + pos, sizeof (Uint16));
168 schuur 1.1 pos+=sizeof(Uint16); 169 CIMType t=(CIMType)ui; 170 return t; 171 } 172
173 david.dillard 1.10 Uint32 BinaryStreamer::extractUint32(const char *ar, Uint32 & pos)
174 schuur 1.1 {
175 konrad.r 1.5 Uint32 ui; //=(Uint32)(ar+pos); 176 memcpy ( &ui, ar + pos, sizeof(Uint32));
177 schuur 1.1 pos+=sizeof(Uint32); 178 return ui; 179 } 180
181 david.dillard 1.10 Boolean BinaryStreamer::extractBoolean(const char *ar, Uint32 & pos)
182 schuur 1.1 {
183 jim.wunderlich 1.17 return ((((Boolean )(ar+(pos++))))!=0);
184 schuur 1.1 } 185 186 187 188
189 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMClass& cls)
190 schuur 1.1 { 191 CIMClassRep *rep=cls._rep; 192 static BINREP_CLASS_PREAMBLE_V1(preamble);
193 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
194 schuur 1.1 195 append(out,rep->getClassName()); 196 197 append(out,rep->getSuperClassName()); 198 199 Uint16 qn=rep->getQualifierCount(); 200 append(out,qn); 201 for (Uint16 i=0; i<qn; i++) { 202 const CIMQualifier &cq=rep->getQualifier(i); 203 toBin(out,cq); 204 } 205 206 Uint16 pn=rep->getPropertyCount(); 207 append(out,pn); 208 for (Uint16 i = 0; i < pn; i++) { 209 toBin(out,rep->getProperty(i)); 210 } 211 212 Uint16 mn=rep->getMethodCount(); 213 append(out,mn); 214 for (Uint16 i = 0; i < mn; i++) { 215 schuur 1.1 toBin(out,rep->getMethod(i)); 216 } 217 218 append(out,rep->_resolved); 219 } 220 221
222 david.dillard 1.10 CIMClass BinaryStreamer::extractClass(const Array<char>& in, Uint32 & pos, const String &path)
223 schuur 1.1 {
224 konrad.r 1.8 #ifdef TYPE_CONV 225 AutoPtr<record_preamble> preamble(new record_preamble()); 226 227 Uint32 idx = pos; 228 memcpy( &preamble->_format, in.getData() +idx, sizeof(Uint8)); 229 idx+=sizeof(Uint8); 230 memcpy( &preamble->_pVersion, in.getData()+idx, sizeof(Uint8)); 231 idx+=sizeof(Uint8); 232 memcpy( &preamble->_pLenAndCtl, in.getData()+idx, sizeof(Uint16)); 233 idx+=sizeof(Uint16); 234 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 235 idx+=sizeof(Uint8); 236 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 237 //idx+=sizeof(Uint8); 238 #else
239 schuur 1.1 BINREP_RECORD_IN(preamble,in,pos);
240 konrad.r 1.8 #endif
241 david.dillard 1.10 const char *ar=in.getData();
242 schuur 1.1 243 try { 244 if (!preamble->endogenous()) { 245 throw BinException(BINREP_CLASS,String("Incompatible Binary Repository not supported")); 246 } 247 if (preamble->type()!=BINREP_CLASS) { 248 throw BinException(BINREP_CLASS,String("Expected CIMClass subtype not found")); 249 } 250 251 pos+=preamble->size(); 252 253 switch (preamble->version()) { 254 case BINREP_CLASS_V1: { 255 256 CIMName name=extractName(ar,pos); //if (name=="CIM_Memory") asm("int $3"); 257 CIMName super=extractName(ar,pos); 258 CIMClass cls(name,super); 259 260 Uint16 qn=extractUint16(ar,pos); 261 for (Uint16 i=0; i<qn; i++) { 262 CIMQualifier q=extractQualifier(in,pos); 263 schuur 1.1 cls.addQualifier(q); 264 } 265 266 Uint16 pn=extractUint16(ar,pos); 267 for (Uint16 i=0; i<pn; i++) { 268 CIMProperty p=extractProperty(in,pos); 269 cls.addProperty(p); 270 } 271 272 Uint16 mn=extractUint16(ar,pos); 273 for (Uint16 i=0; i<mn; i++) { 274 CIMMethod m=extractMethod(in,pos); 275 cls.addMethod(m); 276 } 277 278 cls._rep->_resolved=extractBoolean(ar,pos); 279 return cls; 280 } 281 default: 282 throw BinException(BINREP_CLASS,String("CIMClass subtype version ")+ 283 CIMValue(preamble->version()).toString()+" not supported "); 284 schuur 1.1 } 285 } 286 catch (BinException &be) { 287 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,"Binary Repository integraty failure: "+ 288 be.message+" - Accessing class: "+path); 289 }
290 gs.keenan 1.16 PEGASUS_UNREACHABLE(return CIMClass();)
291 schuur 1.1 } 292 293 294 295 296
297 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMInstance& inst)
298 schuur 1.1 { 299 CIMInstanceRep *rep=inst._rep; 300 301 static BINREP_INSTANCE_PREAMBLE_V1(preamble);
302 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
303 schuur 1.1 304 append(out,rep->getPath()); 305 306 Uint16 qn=rep->getQualifierCount(); 307 append(out,qn); 308 for (Uint16 i=0; i<qn; i++) { 309 const CIMQualifier &cq=rep->getQualifier(i); 310 toBin(out,cq); 311 } 312 313 Uint16 pn=rep->getPropertyCount(); 314 append(out,pn); 315 for (Uint16 i = 0; i < pn; i++) { 316 toBin(out,rep->getProperty(i)); 317 } 318 319 append(out,rep->_resolved); 320 } 321 322
323 david.dillard 1.10 CIMInstance BinaryStreamer::extractInstance(const Array<char>& in, Uint32 & pos,
324 schuur 1.1 const String & path) 325 {
326 konrad.r 1.8 327 #ifdef TYPE_CONV 328 AutoPtr<record_preamble> preamble(new record_preamble()); 329 330 Uint32 idx = pos; 331 memcpy( &preamble->_format, in.getData() +idx, sizeof(Uint8)); 332 idx+=sizeof(Uint8); 333 memcpy( &preamble->_pVersion, in.getData()+idx, sizeof(Uint8)); 334 idx+=sizeof(Uint8); 335 memcpy( &preamble->_pLenAndCtl, in.getData()+idx, sizeof(Uint16)); 336 idx+=sizeof(Uint16); 337 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 338 idx+=sizeof(Uint8); 339 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 340 //idx+=sizeof(Uint8); 341 #else
342 schuur 1.1 BINREP_RECORD_IN(preamble,in,pos);
343 konrad.r 1.8 #endif
344 david.dillard 1.10 const char *ar=in.getData();
345 schuur 1.1 346 try { 347 if (!preamble->endogenous()) { 348 throw BinException(BINREP_INSTANCE,String("Incompatible Binary Repository not supported")); 349 } 350 if (preamble->type()!=BINREP_INSTANCE) { 351 throw BinException(BINREP_INSTANCE,String("Expected CIMInstance subtype not found")); 352 } 353 354 pos+=preamble->size(); 355 356 switch (preamble->version()) { 357 case BINREP_INSTANCE_V1: { 358 359 CIMObjectPath op=extractObjectPath(ar,pos); 360 CIMInstance inst(op.getClassName()); 361 inst.setPath(op); 362 363 Uint16 qn=extractUint16(ar,pos); 364 for (Uint16 i=0; i<qn; i++) { 365 CIMQualifier q=extractQualifier(in,pos); 366 schuur 1.1 inst.addQualifier(q); 367 } 368 369 Uint16 pn=extractUint16(ar,pos); 370 for (Uint16 i=0; i<pn; i++) { 371 CIMProperty p=extractProperty(in,pos); 372 inst.addProperty(p); 373 } 374 375 inst._rep->_resolved=extractBoolean(ar,pos); 376 377 return inst; 378 } 379 default: 380 throw BinException(BINREP_INSTANCE,String("CIMInstance subtype version ")+ 381 CIMValue(preamble->version()).toString()+" not supported "); 382 } 383 } 384 catch (BinException &be) { 385 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,"Binary Repository integraty failure: "+ 386 be.message+" - Accessing instance: "+path); 387 schuur 1.1 }
388 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMInstance(); )
389 schuur 1.1 } 390 391 392 393 394 395
396 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMQualifierDecl& qdc)
397 schuur 1.1 { 398 static BINREP_QUALIFIERDECL_PREAMBLE_V1(preamble);
399 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
400 schuur 1.1 401 append(out,qdc.getName()); 402 403 toBin(out,qdc.getValue()); 404 405 toBin(out,qdc.getScope()); 406 407 toBin(out,qdc.getFlavor()); 408 409 append(out,qdc.getArraySize()); 410 411 } 412 413
414 david.dillard 1.10 CIMQualifierDecl BinaryStreamer::extractQualifierDecl(const Array<char>& in, Uint32 & pos,
415 schuur 1.1 const String &path) 416 {
417 konrad.r 1.8 #ifdef TYPE_CONV 418 AutoPtr<record_preamble> preamble(new record_preamble()); 419 420 Uint32 idx = pos; 421 memcpy( &preamble->_format, in.getData() +idx, sizeof(Uint8)); 422 idx+=sizeof(Uint8); 423 memcpy( &preamble->_pVersion, in.getData()+idx, sizeof(Uint8)); 424 idx+=sizeof(Uint8); 425 memcpy( &preamble->_pLenAndCtl, in.getData()+idx, sizeof(Uint16)); 426 idx+=sizeof(Uint16); 427 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 428 idx+=sizeof(Uint8); 429 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 430 //idx+=sizeof(Uint8); 431 #else
432 schuur 1.1 BINREP_RECORD_IN(preamble,in,pos);
433 konrad.r 1.8 #endif
434 david.dillard 1.10 const char *ar=in.getData();
435 schuur 1.1 436 try { 437 if (!preamble->endogenous()) { 438 throw BinException(BINREP_QUALIFIERDECL,String 439 ("Incompatible Binary Repository not supported")); 440 } 441 if (preamble->type()!=BINREP_QUALIFIERDECL) { 442 throw BinException(BINREP_QUALIFIERDECL,String( 443 "Expected CIMQualifierDecl subtype not found")); 444 } 445 446 pos+=preamble->size(); 447 448 switch (preamble->version()) { 449 case BINREP_INSTANCE_V1: { 450 451 CIMName name=extractName(ar,pos); 452 CIMValue val=extractValue(in,pos); 453 CIMScope scp=extractScope(in,pos); 454 CIMFlavor fl=extractFlavor(in,pos); 455 Uint32 as=extractUint32(ar,pos); 456 schuur 1.1 457 CIMQualifierDecl qdl(name,val,scp,fl,as); 458 459 return qdl; 460 } 461 default: 462 throw BinException(BINREP_INSTANCE,String("CIMInstance subtype version ")+ 463 CIMValue(preamble->version()).toString()+" not supported "); 464 } 465 } 466 catch (BinException &be) { 467 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,"Binary Repository integraty failure: "+ 468 be.message+" - Accessing instance: "+path); 469 }
470 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMQualifierDecl(); )
471 schuur 1.1 } 472 473 474 475 476
477 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMMethod &meth)
478 schuur 1.1 { 479 CIMMethodRep *rep=meth._rep; 480 481 static BINREP_METHOD_PREAMBLE_V1(preamble);
482 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
483 schuur 1.1 484 append(out,rep->getName()); 485 486 append(out,rep->getType()); 487 488 append(out,rep->getClassOrigin()); 489 490 append(out,rep->getPropagated()); 491 492 Uint16 qn=rep->getQualifierCount(); 493 append(out,qn); 494 for (Uint16 i=0; i<qn; i++) { 495 const CIMQualifier &cq=rep->getQualifier(i); 496 toBin(out,cq); 497 } 498 499 Uint16 pn=rep->getParameterCount();
500 david.dillard 1.10 out.append((char*)&pn,sizeof(Uint16));
501 schuur 1.1 for (Uint16 i = 0; i < pn; i++) { 502 toBin(out,rep->getParameter(i)); 503 } 504 } 505 506
507 david.dillard 1.10 CIMMethod BinaryStreamer::extractMethod(const Array<char>& in, Uint32 & pos)
508 schuur 1.1 {
509 konrad.r 1.8 #ifdef TYPE_CONV 510 AutoPtr<subtype_preamble> preamble(new subtype_preamble()); 511 512 Uint32 idx = pos; 513 memcpy( &preamble->_pLength, in.getData() +idx, sizeof(Uint8)); 514 idx+=sizeof(Uint8); 515 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 516 idx+=sizeof(Uint8); 517 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 518 //idx+=sizeof(Uint8); 519 #else
520 schuur 1.1 BINREP_SUBTYPE_IN(preamble,in,pos);
521 konrad.r 1.8 #endif
522 david.dillard 1.10 const char *ar=in.getData();
523 schuur 1.1 524 if (preamble->type()!=BINREP_METHOD) { 525 throw BinException(BINREP_METHOD,String("Expected CIMMethod subtype not found")); 526 } 527 528 pos+=preamble->size(); 529 530 switch (preamble->version()) { 531 case BINREP_METHOD_V1: { 532 533 CIMName name=extractName(ar,pos); 534 CIMType type=extractType(ar,pos); 535 CIMName orig=extractName(ar,pos); 536 Boolean prpg=extractBoolean(ar,pos); 537 538 CIMMethod meth(name,type,orig,prpg); 539 540 Uint16 qn=extractUint16(ar,pos); 541 for (Uint16 i=0; i<qn; i++) { 542 CIMQualifier q=extractQualifier(in,pos); 543 meth.addQualifier(q); 544 schuur 1.1 } 545 546 Uint16 pn=extractUint16(ar,pos); 547 for (Uint16 i=0; i<pn; i++) { 548 CIMParameter p=extractParameter(in,pos); 549 meth.addParameter(p); 550 } 551 552 return meth; 553 } 554 default: ; 555 throw BinException(BINREP_METHOD,String("CIMMethod subtype version ")+ 556 CIMValue(preamble->version()).toString()+" not supported "); 557 }
558 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMMethod(); )
559 schuur 1.1 } 560 561 562 563 564
565 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMParameter& prm)
566 schuur 1.1 { 567 CIMParameterRep *rep=prm._rep; 568 569 static BINREP_PARAMETER_PREAMBLE_V1(preamble);
570 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
571 schuur 1.1 572 append(out,rep->getName()); 573 574 append(out,rep->getType()); 575 576 append(out,rep->isArray()); 577 578 append(out,rep->getArraySize()); 579 580 append(out,rep->getReferenceClassName()); 581 582 Uint16 qn=rep->getQualifierCount(); 583 append(out,qn); 584 for (Uint16 i=0; i<qn; i++) { 585 const CIMQualifier &cq=rep->getQualifier(i); 586 toBin(out,cq); 587 } 588 } 589
590 david.dillard 1.10 CIMParameter BinaryStreamer::extractParameter(const Array<char>& in, Uint32 &pos)
591 schuur 1.1 {
592 konrad.r 1.8 #ifdef TYPE_CONV 593 AutoPtr<subtype_preamble> preamble(new subtype_preamble()); 594 595 Uint32 idx = pos; 596 memcpy( &preamble->_pLength, in.getData() +idx, sizeof(Uint8)); 597 idx+=sizeof(Uint8); 598 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 599 idx+=sizeof(Uint8); 600 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 601 //idx+=sizeof(Uint8); 602 #else
603 schuur 1.1 BINREP_SUBTYPE_IN(preamble,in,pos);
604 konrad.r 1.8 #endif
605 david.dillard 1.10 const char *ar=in.getData();
606 schuur 1.1 607 if (preamble->type()!=BINREP_PARAMETER) { 608 throw BinException(BINREP_PARAMETER,String("Expected CIMParameter subtype not found")); 609 } 610 611 pos+=preamble->size(); 612 613 switch (preamble->version()) { 614 case BINREP_PARAMETER_V1: { 615 616 CIMName name=extractName(ar,pos); 617 CIMType type=extractType(ar,pos); 618 Boolean isAr=extractBoolean(ar,pos); 619 Uint32 as=extractUint32(ar,pos); 620 CIMName clsr=extractName(ar,pos); 621 622 CIMParameter parm(name,type,isAr,as,clsr); 623 624 Uint16 qn=extractUint16(ar,pos); 625 for (Uint16 i=0; i<qn; i++) { 626 CIMQualifier q=extractQualifier(in,pos); 627 schuur 1.1 parm.addQualifier(q); 628 } 629 630 return parm; 631 } 632 default: ; 633 throw BinException(BINREP_PARAMETER,String("CIMParameter subtype version ")+ 634 CIMValue(preamble->version()).toString()+" not supported "); 635 }
636 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMParameter(); )
637 schuur 1.1 } 638 639 640 641
642 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMProperty& prop)
643 schuur 1.1 { 644 CIMPropertyRep *rep=prop._rep; 645 646 static BINREP_PROPERTY_PREAMBLE_V1(preamble);
647 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
648 schuur 1.1 649 append(out,rep->getName()); 650 651 toBin(out,rep->getValue()); 652 653 append(out,rep->getArraySize()); 654 655 append(out,rep->getReferenceClassName()); 656 657 append(out,rep->getClassOrigin()); 658 659 append(out,rep->getPropagated()); 660 661 Uint16 qn=rep->getQualifierCount(); 662 append(out,qn); 663 for (Uint16 i=0; i<qn; i++) { 664 const CIMQualifier &cq=rep->getQualifier(i); 665 toBin(out,cq); 666 } 667 } 668 669 schuur 1.1
670 david.dillard 1.10 CIMProperty BinaryStreamer::extractProperty(const Array<char>& in, Uint32 &pos)
671 schuur 1.1 {
672 konrad.r 1.8 #ifdef TYPE_CONV 673 AutoPtr<subtype_preamble> preamble(new subtype_preamble()); 674 675 Uint32 idx = pos; 676 memcpy( &preamble->_pLength, in.getData() +idx, sizeof(Uint8)); 677 idx+=sizeof(Uint8); 678 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 679 idx+=sizeof(Uint8); 680 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 681 //idx+=sizeof(Uint8); 682 #else
683 schuur 1.1 BINREP_SUBTYPE_IN(preamble,in,pos);
684 konrad.r 1.8 #endif
685 david.dillard 1.10 const char *ar=in.getData();
686 schuur 1.1 687 if (preamble->type()!=BINREP_PROPERTY) { 688 throw BinException(BINREP_PROPERTY,String("Expected CIMProperty subtype not found")); 689 } 690 691 pos+=preamble->size(); 692 693 switch (preamble->version()) { 694 case BINREP_PROPERTY_V1: { 695 696 CIMName name=extractName(ar,pos); 697 CIMValue val=extractValue(in,pos); 698 Uint32 as=extractUint32(ar,pos); 699 CIMName clsr=extractName(ar,pos); 700 CIMName orig=extractName(ar,pos); 701 Boolean prpg=extractBoolean(ar,pos); 702 703 CIMProperty prop(name,val,as,clsr,orig,prpg); 704 705 Uint16 qn=extractUint16(ar,pos); 706 for (Uint16 i=0; i<qn; i++) { 707 schuur 1.1 CIMQualifier q=extractQualifier(in,pos); 708 prop.addQualifier(q); 709 } 710 711 return prop; 712 } 713 default: ; 714 throw BinException(BINREP_PROPERTY,String("CIMProperty subtype version ")+ 715 CIMValue(preamble->version()).toString()+" not supported "); 716 }
717 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMProperty(); )
718 schuur 1.1 } 719 720 721 722 723
724 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMFlavor& flav)
725 schuur 1.1 {
726 david.dillard 1.10 out.append((char*)&flav.cimFlavor,sizeof(flav.cimFlavor));
727 schuur 1.1 } 728 729
730 david.dillard 1.10 CIMFlavor BinaryStreamer::extractFlavor(const Array<char>& in, Uint32 & pos)
731 schuur 1.1 { 732 CIMFlavor flav; 733 flav.cimFlavor=extractUint32(in.getData(),pos); 734 return flav; 735 } 736 737 738 739 740
741 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMScope& scp)
742 schuur 1.1 {
743 david.dillard 1.10 out.append((char*)&scp.cimScope,sizeof(scp.cimScope));
744 schuur 1.1 } 745 746
747 david.dillard 1.10 CIMScope BinaryStreamer::extractScope(const Array<char>& in, Uint32 & pos)
748 schuur 1.1 { 749 CIMScope scp; 750 scp.cimScope=extractUint32(in.getData(),pos); 751 return scp; 752 } 753 754 755 756
757 david.dillard 1.10 void BinaryStreamer::toBin(Array<char>& out, const CIMQualifier& qual)
758 schuur 1.1 { 759 CIMQualifierRep *rep=qual._rep; 760 761 static BINREP_QUALIFIER_PREAMBLE_V1(preamble);
762 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
763 schuur 1.1 764 CIMName name=rep->getName(); 765 append(out,name); 766
767 dave.sudlik 1.4 toBin(out,rep->getValue());
768 schuur 1.1 769 toBin(out,rep->getFlavor()); 770 771 append(out,rep->getPropagated()); 772 } 773 774
775 david.dillard 1.10 CIMQualifier BinaryStreamer::extractQualifier(const Array<char>& in, Uint32 & pos)
776 schuur 1.1 {
777 konrad.r 1.8 #ifdef TYPE_CONV 778 AutoPtr<subtype_preamble> preamble(new subtype_preamble()); 779 780 Uint32 idx = pos; 781 memcpy( &preamble->_pLength, in.getData() +idx, sizeof(Uint8)); 782 idx+=sizeof(Uint8); 783 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 784 idx+=sizeof(Uint8); 785 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 786 //idx+=sizeof(Uint8); 787 #else
788 schuur 1.1 BINREP_SUBTYPE_IN(preamble,in,pos);
789 konrad.r 1.8 #endif
790 david.dillard 1.10 const char *ar=in.getData();
791 schuur 1.1 792 if (preamble->type()!=BINREP_QUALIFIER) { 793 throw BinException(BINREP_QUALIFIER,String("Expected CIMQualifier subtype not found")); 794 } 795 796 pos+=preamble->size(); 797 798 switch (preamble->version()) { 799 case BINREP_QUALIFIER_V1: { 800 801 CIMName name=extractName(ar,pos); 802 CIMValue val=extractValue(in,pos); 803 CIMFlavor fl=extractFlavor(in,pos); 804 Boolean prpg=extractBoolean(ar,pos); 805 806 CIMQualifier q(name,val,fl,prpg); 807 808 return q; 809 } 810 default: ; 811 throw BinException(BINREP_QUALIFIER,String("CIMQualifier subtype version ")+ 812 schuur 1.1 CIMValue(preamble->version()).toString()+" not supported "); 813 }
814 carson.hovey 1.14 PEGASUS_UNREACHABLE( return CIMQualifier(); )
815 schuur 1.1 } 816 817 818 819
820 david.dillard 1.10 void BinaryStreamer::toBin(Array<char> & out, const CIMValue& val)
821 schuur 1.1 { 822 CIMValueRep *_rep=val._rep; 823 824 static BINREP_VALUE_PREAMBLE_V1(preamble);
825 david.dillard 1.10 out.append((char*)&preamble,sizeof(preamble));
826 schuur 1.1 827 append(out,val.getType()); 828 829 Boolean isArray=val.isArray(); 830 append(out,isArray); 831 832 Uint32 as=0; 833 834 if (isArray) { 835 as=val.getArraySize(); 836 append(out,as); 837 } 838 839 Boolean isNull=val.isNull(); 840 append(out,isNull); 841 842 if (!isNull) { 843 if (isArray) { 844 switch (val.getType()) { 845 case CIMTYPE_BOOLEAN: {
846 david.dillard 1.10 out.append((char)_rep->_u._booleanArray->getData(),sizeof(Boolean)as);
847 schuur 1.1 } 848 break; 849 case CIMTYPE_UINT8: {
850 david.dillard 1.10 out.append((char)_rep->_u._uint8Array->getData(),sizeof(Uint8)as);
851 schuur 1.1 } 852 break; 853 case CIMTYPE_SINT8: {
854 david.dillard 1.10 out.append((char)_rep->_u._sint8Array->getData(),sizeof(Sint8)as);
855 schuur 1.1 } 856 break; 857 case CIMTYPE_UINT16: {
858 david.dillard 1.10 out.append((char)_rep->_u._uint16Array->getData(),sizeof(Uint16)as);
859 schuur 1.1 } 860 break; 861 case CIMTYPE_SINT16: {
862 david.dillard 1.10 out.append((char)_rep->_u._sint16Array->getData(),sizeof(Sint16)as);
863 schuur 1.1 } 864 break; 865 case CIMTYPE_UINT32: {
866 david.dillard 1.10 out.append((char)_rep->_u._uint32Array->getData(),sizeof(Uint32)as);
867 schuur 1.1 } 868 break; 869 case CIMTYPE_SINT32: {
870 david.dillard 1.10 out.append((char)_rep->_u._sint32Array->getData(),sizeof(Sint32)as);
871 schuur 1.1 } 872 break; 873 case CIMTYPE_UINT64: {
874 david.dillard 1.10 out.append((char)_rep->_u._uint64Array->getData(),sizeof(Uint64)as);
875 schuur 1.1 } 876 break; 877 case CIMTYPE_SINT64: {
878 david.dillard 1.10 out.append((char)_rep->_u._sint64Array->getData(),sizeof(Uint64)as);
879 schuur 1.1 } 880 break; 881 case CIMTYPE_REAL32: {
882 david.dillard 1.10 out.append((char)_rep->_u._real32Array->getData(),sizeof(Real32)as);
883 schuur 1.1 } 884 break; 885 case CIMTYPE_REAL64: {
886 david.dillard 1.10 out.append((char)_rep->_u._real64Array->getData(),sizeof(Real64)as);
887 schuur 1.1 } 888 break; 889 case CIMTYPE_CHAR16: {
890 david.dillard 1.10 out.append((char)_rep->_u._char16Array->getData(),sizeof(Char16)as);
891 schuur 1.1 } 892 break; 893 case CIMTYPE_STRING: { 894 for (Uint32 i=0; i<as; i++) { 895 CString ustr=((_rep->_u._stringArray))[i].getCString(); 896 Uint32 sz=strlen((const char)ustr);
897 david.dillard 1.10 out.append((char)&sz,sizeof(Uint32)); 898 out.append((char)((const char*)ustr),sz);
899 schuur 1.1 } 900 } 901 break; 902 case CIMTYPE_DATETIME: { 903 for (Uint32 i=0; i<as; i++) { 904 String dts=(*(_rep->_u._dateTimeArray))[i].toString(); 905 Sint32 dtl=dts.size();
906 david.dillard 1.10 out.append((char)&dtl,sizeof(Sint32)); 907 out.append((char)dts.getChar16Data(),dtl*sizeof(Char16));
908 schuur 1.1 } 909 } 910 break; 911 case CIMTYPE_REFERENCE: { 912 for (Uint32 i=0; i<as; i++) { 913 String rfs=(*(_rep->_u._referenceArray))[i].toString(); 914 Sint32 rfl=rfs.size();
915 david.dillard 1.10 out.append((char)&rfl,sizeof(Sint32)); 916 out.append((char)rfs.getChar16Data(),rfl*sizeof(Char16));
917 schuur 1.1 } 918 } 919 break;
920 dave.sudlik 1.15 case CIMTYPE_OBJECT: { 921 for (Uint32 i=0; i<as; i++) { 922 String obs=((_rep->_u._objectArray))[i].toString(); 923 Sint32 obl=obs.size(); 924 out.append((char)&obl,sizeof(Sint32)); 925 out.append((char)obs.getChar16Data(),oblsizeof(Char16)); 926 } 927 } 928 break;
929 schuur 1.1 } 930 } 931 932 else switch (val.getType()) { 933 case CIMTYPE_BOOLEAN:
934 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Boolean)); break;
935 schuur 1.1 case CIMTYPE_UINT8:
936 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Uint8)); break;
937 schuur 1.1 case CIMTYPE_SINT8:
938 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Sint8)); break;
939 schuur 1.1 case CIMTYPE_UINT16:
940 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Uint16)); break;
941 schuur 1.1 case CIMTYPE_SINT16:
942 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Sint16)); break;
943 schuur 1.1 case CIMTYPE_UINT32:
944 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Uint32)); break;
945 schuur 1.1 case CIMTYPE_SINT32:
946 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Sint32)); break;
947 schuur 1.1 case CIMTYPE_UINT64:
948 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Uint64)); break;
949 schuur 1.1 case CIMTYPE_SINT64:
950 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Uint64)); break;
951 schuur 1.1 case CIMTYPE_REAL32:
952 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Real32)); break;
953 schuur 1.1 case CIMTYPE_REAL64:
954 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Real64)); break;
955 schuur 1.1 case CIMTYPE_CHAR16:
956 david.dillard 1.10 out.append((char*)&_rep->_u,sizeof(Char16)); break;
957 schuur 1.1 case CIMTYPE_STRING: { 958 CString ustr=_rep->_u._stringValue->getCString(); 959 Uint32 sz=strlen((const char*)ustr);
960 david.dillard 1.10 out.append((char)&sz,sizeof(Uint32)); 961 out.append((char)((const char*)ustr),sz);
962 schuur 1.1 } 963 break; 964 case CIMTYPE_DATETIME: { 965 String dts=_rep->_u._dateTimeValue->toString(); 966 Sint32 dtl=dts.size();
967 david.dillard 1.10 out.append((char)&dtl,sizeof(Sint32)); 968 out.append((char)dts.getChar16Data(),dtl*sizeof(Char16));
969 schuur 1.1 } 970 break; 971 case CIMTYPE_REFERENCE: { 972 String rfs=_rep->_u._referenceValue->toString(); 973 Sint32 rfl=rfs.size();
974 david.dillard 1.10 out.append((char)&rfl,sizeof(Sint32)); 975 out.append((char)rfs.getChar16Data(),rfl*sizeof(Char16));
976 schuur 1.1 } 977 break;
978 dave.sudlik 1.15 case CIMTYPE_OBJECT: { 979 String obs=_rep->_u._objectValue->toString(); 980 Sint32 obl=obs.size(); 981 out.append((char)&obl,sizeof(Sint32)); 982 out.append((char)obs.getChar16Data(),obl*sizeof(Char16)); 983 } 984 break;
985 schuur 1.1 } 986 } 987 else { 988 } 989 } 990 991
992 david.dillard 1.10 CIMValue BinaryStreamer::extractValue(const Array<char>& in, Uint32 & pos)
993 schuur 1.1 {
994 konrad.r 1.8 #ifdef TYPE_CONV 995 AutoPtr<subtype_preamble> preamble(new subtype_preamble()); 996 997 Uint32 idx = pos; 998 memcpy( &preamble->_pLength, in.getData() +idx, sizeof(Uint8)); 999 idx+=sizeof(Uint8); 1000 memcpy( &preamble->_type, in.getData()+idx, sizeof(Uint8)); 1001 idx+=sizeof(Uint8); 1002 memcpy( &preamble->_tVersion, in.getData()+idx, sizeof(Uint8)); 1003 //idx+=sizeof(Uint8); 1004 #else
1005 schuur 1.1 BINREP_SUBTYPE_IN(preamble,in,pos);
1006 konrad.r 1.8 #endif
1007 david.dillard 1.10 const char *ar=in.getData();
1008 schuur 1.1 1009 if (preamble->type()!=BINREP_VALUE) { 1010 throw BinException(BINREP_VALUE,String("Expected CIMValue subtype not found")); 1011 } 1012 1013 pos+=preamble->size(); 1014 1015 Uint32 as=0; 1016 1017 switch (preamble->version()) { 1018 case BINREP_VALUE_V1: { 1019
1020 david.dillard 1.10 const char *ar=in.getData();
1021 schuur 1.1 1022 CIMType type=extractType(ar,pos); 1023 1024 Boolean isArray=extractBoolean(ar,pos); 1025 if (isArray) 1026 as=extractUint32(ar,pos); 1027 1028 Boolean isNull=extractBoolean(ar,pos); 1029 1030 if (!isNull) { 1031 if (isArray) { 1032 1033 CIMValue val(type,isArray,as); 1034 1035 switch (type) { 1036 case CIMTYPE_BOOLEAN: {
1037 konrad.r 1.7 #ifdef TYPE_CONV 1038 Array<Boolean> a_val; 1039 a_val.reserveCapacity(as); 1040 for (Uint32 i =0; i < as*sizeof(Boolean); i+=sizeof(Boolean)) { 1041 Boolean b; 1042 memcpy( &b, ar + pos + i, sizeof(Boolean)); 1043 a_val.append(b); 1044 } 1045 val.set(a_val); 1046 #else
1047 schuur 1.1 val.set(Array<Boolean>((Boolean*)(ar+pos),as));
1048 konrad.r 1.7 #endif
1049 schuur 1.1 pos+=sizeof(Boolean)*as; 1050 } 1051 break; 1052 case CIMTYPE_UINT8: {
1053 konrad.r 1.7 #ifdef TYPE_CONV 1054 Array<Uint8> a_val; 1055 a_val.reserveCapacity(as); 1056 for (Uint32 i =0; i < as*sizeof(Uint8); i+=sizeof(Uint8)) { 1057 Uint8 val; 1058 memcpy( &val, ar + pos + i, sizeof(Uint8)); 1059 a_val.append(val); 1060 } 1061 val.set(a_val); 1062 #else
1063 schuur 1.1 val.set(Array<Uint8>((Uint8*)(ar+pos),as));
1064 konrad.r 1.7 #endif
1065 schuur 1.1 pos+=sizeof(Uint8)*as; 1066 } 1067 break; 1068 case CIMTYPE_SINT8: {
1069 konrad.r 1.7 #ifdef TYPE_CONV 1070 Array<Sint8> a_val; 1071 a_val.reserveCapacity(as);
1072 david.dillard 1.10 for (Uint32 i =0; i < as*sizeof(char); i+=sizeof(Sint8)) { 1073 char val;
1074 konrad.r 1.7 memcpy( &val, ar + pos + i, sizeof(Sint8)); 1075 a_val.append(val); 1076 } 1077 val.set(a_val); 1078 #else
1079 david.dillard 1.10 val.set(Array<Sint8>((Sint8 *)(ar+pos),as));
1080 konrad.r 1.7 #endif
1081 schuur 1.1 pos+=sizeof(Sint8)*as; 1082 } 1083 break; 1084 case CIMTYPE_UINT16: {
1085 konrad.r 1.7 #ifdef TYPE_CONV 1086 Array<Uint16> a_val; 1087 a_val.reserveCapacity(as); 1088 for (Uint32 i =0; i < as*sizeof(Uint16); i+=sizeof(Uint16)) { 1089 Uint16 val; 1090 memcpy( &val, ar + pos + i, sizeof(Uint16)); 1091 a_val.append(val); 1092 } 1093 val.set(a_val); 1094 #else
1095 schuur 1.1 val.set(Array<Uint16>((Uint16*)(ar+pos),as));
1096 konrad.r 1.7 #endif
1097 schuur 1.1 pos+=sizeof(Uint16)*as; 1098 } 1099 break; 1100 case CIMTYPE_SINT16: {
1101 konrad.r 1.7 #ifdef TYPE_CONV 1102 Array<Sint16> a_val; 1103 a_val.reserveCapacity(as); 1104 for (Uint32 i =0; i < as*sizeof(Sint16); i+=sizeof(Sint16)) { 1105 Sint16 val; 1106 memcpy( &val, ar + pos + i, sizeof(Sint16)); 1107 a_val.append(val); 1108 } 1109 val.set(a_val); 1110 #else
1111 schuur 1.1 val.set(Array<Sint16>((Sint16*)(ar+pos),as));
1112 konrad.r 1.7 #endif
1113 schuur 1.1 pos+=sizeof(Sint16)*as; 1114 } 1115 break; 1116 case CIMTYPE_UINT32: {
1117 konrad.r 1.7 #ifdef TYPE_CONV 1118 Array<Uint32> a_val; 1119 a_val.reserveCapacity(as); 1120 for (Uint32 i =0; i < as*sizeof(Uint32); i+=sizeof(Uint32)) { 1121 Uint32 val; 1122 memcpy( &val, ar + pos + i, sizeof(Uint32)); 1123 a_val.append(val); 1124 } 1125 val.set(a_val); 1126 #else
1127 schuur 1.1 val.set(Array<Uint32>((Uint32*)(ar+pos),as));
1128 konrad.r 1.7 #endif
1129 schuur 1.1 pos+=sizeof(Uint32)*as; 1130 } 1131 break; 1132 case CIMTYPE_SINT32: {
1133 konrad.r 1.7 #ifdef TYPE_CONV 1134 Array<Sint32> a_val; 1135 a_val.reserveCapacity(as); 1136 for (Uint32 i =0; i < as*sizeof(Sint32); i+=sizeof(Sint32)) { 1137 Sint32 val; 1138 memcpy( &val, ar + pos + i, sizeof(Sint32)); 1139 a_val.append(val); 1140 } 1141 val.set(a_val); 1142 #else
1143 schuur 1.1 val.set(Array<Sint32>((Sint32*)(ar+pos),as));
1144 konrad.r 1.7 #endif
1145 schuur 1.1 pos+=sizeof(Sint32)*as; 1146 } 1147 break; 1148 case CIMTYPE_UINT64: {
1149 konrad.r 1.7 #ifdef TYPE_CONV 1150 Array<Uint64> a_val; 1151 a_val.reserveCapacity(as); 1152 for (Uint32 i =0; i < as*sizeof(Uint64); i+=sizeof(Uint64)) { 1153 Uint64 val; 1154 memcpy( &val, ar + pos + i, sizeof(Uint64)); 1155 a_val.append(val); 1156 } 1157 val.set(a_val); 1158 #else
1159 schuur 1.1 val.set(Array<Uint64>((Uint64*)(ar+pos),as));
1160 konrad.r 1.7 #endif
1161 schuur 1.1 pos+=sizeof(Uint64)*as; 1162 } 1163 break; 1164 case CIMTYPE_SINT64: {
1165 konrad.r 1.7 #ifdef TYPE_CONV 1166 Array<Sint64> a_val; 1167 a_val.reserveCapacity(as); 1168 for (Uint32 i =0; i < as*sizeof(Sint64); i+=sizeof(Sint64)) { 1169 Sint64 val; 1170 memcpy( &val, ar + pos + i, sizeof(Sint64)); 1171 a_val.append(val); 1172 } 1173 val.set(a_val); 1174 #else
1175 schuur 1.1 val.set(Array<Sint64>((Sint64*)(ar+pos),as));
1176 konrad.r 1.7 #endif
1177 schuur 1.1 pos+=sizeof(Sint64)*as; 1178 } 1179 break; 1180 case CIMTYPE_REAL32: {
1181 konrad.r 1.7 #ifdef TYPE_CONV 1182 Array<Real32> a_val; 1183 a_val.reserveCapacity(as); 1184 for (Uint32 i =0; i < as*sizeof(Real32); i+=sizeof(Real32)) { 1185 Real32 val; 1186 memcpy( &val, ar + pos + i, sizeof(Real32)); 1187 a_val.append(val); 1188 } 1189 val.set(a_val); 1190 #else
1191 schuur 1.1 val.set(Array<Real32>((Real32*)(ar+pos),as));
1192 konrad.r 1.7 #endif
1193 schuur 1.1 pos+=sizeof(Real32)*as; 1194 } 1195 break; 1196 case CIMTYPE_REAL64: {
1197 konrad.r 1.7 #ifdef TYPE_CONV 1198 Array<Real64> a_val; 1199 a_val.reserveCapacity(as); 1200 for (Uint32 i =0; i < as*sizeof(Real64); i+=sizeof(Real64)) { 1201 Real64 val; 1202 memcpy( &val, ar + pos + i, sizeof(Real64)); 1203 a_val.append(val); 1204 } 1205 val.set(a_val); 1206 #else
1207 schuur 1.1 val.set(Array<Real64>((Real64*)(ar+pos),as));
1208 konrad.r 1.7 #endif
1209 schuur 1.1 pos+=sizeof(Real64)*as; 1210 } 1211 break; 1212 case CIMTYPE_CHAR16: {
1213 konrad.r 1.7 #ifdef TYPE_CONV 1214 Array<Char16> a_val; 1215 a_val.reserveCapacity(as); 1216 for (Uint32 i =0; i < as*sizeof(Char16); i+=sizeof(Char16)) { 1217 Char16 val; 1218 memcpy( &val, ar + pos + i, sizeof(Char16)); 1219 a_val.append(val); 1220 } 1221 val.set(a_val); 1222 #else
1223 schuur 1.1 val.set(Array<Char16>((Char16*)(ar+pos),as));
1224 konrad.r 1.7 #endif
1225 schuur 1.1 pos+=sizeof(Char16)*as; 1226 } 1227 break; 1228 case CIMTYPE_STRING: { 1229 Array<String> sar; 1230 for (Uint32 i=0; i<as; i++) {
1231 konrad.r 1.5 Uint32 sl; //=(Uint32)(ar+pos); 1232 memcpy( &sl, ar+pos, sizeof(Uint32));
1233 schuur 1.1 pos+=sizeof(Uint32); 1234 sar.append(String(((char*)(ar+pos)),sl)); 1235 pos+=sl; 1236 } 1237 val.set(sar); 1238 } 1239 break; 1240 case CIMTYPE_DATETIME: { 1241 Array<CIMDateTime> dar; 1242 for (Uint32 i=0; i<as; i++) {
1243 konrad.r 1.5 Uint32 sl; //=(Uint32)(ar+pos); 1244 memcpy( &sl, ar + pos, sizeof(Uint32));
1245 schuur 1.1 pos+=sizeof(Uint32);
1246 konrad.r 1.7 #ifdef TYPE_CONV 1247 String string; 1248 string.reserveCapacity(sl); 1249 for (Uint32 j=0; j < sl*sizeof(Char16); j+=sizeof(Char16)) { 1250 Char16 char16; 1251 memcpy( &char16, ar + pos + j, sizeof(Char16)); 1252 string.append( char16 ); 1253 } 1254 dar.append(CIMDateTime(string)); 1255 #else
1256 schuur 1.1 dar.append(CIMDateTime(String(((Char16*)(ar+pos)),sl)));
1257 konrad.r 1.7 #endif
1258 schuur 1.1 pos+=sl*sizeof(Char16); 1259 } 1260 val.set(dar); 1261 } 1262 break; 1263 case CIMTYPE_REFERENCE: { 1264 Array<CIMObjectPath> rar; 1265 for (Uint32 i=0; i<as; i++) {
1266 konrad.r 1.5 Uint32 sl; //=(Uint32)(ar+pos); 1267 memcpy( &sl, ar + pos, sizeof(Uint32));
1268 schuur 1.1 pos+=sizeof(Uint32);
1269 konrad.r 1.7 #ifdef TYPE_CONV 1270 String string; 1271 string.reserveCapacity(sl); 1272 for (Uint32 j=0; j < sl*sizeof(Char16); j+=sizeof(Char16)) { 1273 Char16 char16; 1274 memcpy( &char16, ar + pos + j, sizeof(Char16)); 1275 string.append( char16 ); 1276 } 1277 rar.append(CIMObjectPath( string )); 1278 #else
1279 schuur 1.1 rar.append(CIMObjectPath(String(((Char16*)(ar+pos)),sl)));
1280 konrad.r 1.7 #endif
1281 schuur 1.1 pos+=sl*sizeof(Char16); 1282 } 1283 val.set(rar); 1284 } 1285 break; 1286 default: 1287 PEGASUS_ASSERT(false); 1288 } 1289 return val; 1290 } 1291 1292 else { 1293 1294 CIMValue val(type,isArray); 1295 1296 switch (type) { 1297 case CIMTYPE_BOOLEAN:
1298 konrad.r 1.6 Boolean b; 1299 memcpy(&b, ar + pos, sizeof(Boolean)); 1300 //val.set((Boolean)(ar+pos)); 1301 val.set(b);
1302 jim.wunderlich 1.18 pos+=sizeof(Boolean);
1303 schuur 1.1 break; 1304 case CIMTYPE_SINT8:
1305 w.otsuka 1.11 { 1306 Sint8 sint=0;
1307 w.otsuka 1.13 memcpy( &sint, ar + pos, sizeof(Sint8));
1308 konrad.r 1.6 //val.set((Sint8)(ar+pos)); 1309 val.set(sint);
1310 schuur 1.1 pos++;
1311 w.otsuka 1.11 }
1312 schuur 1.1 break; 1313 case CIMTYPE_UINT8:
1314 konrad.r 1.6 Uint8 uint; 1315 //val.set((Uint8)(ar+pos)); 1316 memcpy(&uint, ar + pos, sizeof(Uint8)); 1317 val.set(uint);
1318 schuur 1.1 pos++; 1319 break; 1320 case CIMTYPE_UINT16:
1321 konrad.r 1.6 Uint16 uint16; 1322 //val.set((Uint16)(ar+pos)); 1323 memcpy( &uint16, ar + pos, sizeof(Uint16)); 1324 val.set(uint16);
1325 schuur 1.1 pos+=sizeof(Uint16); 1326 break; 1327 case CIMTYPE_SINT16:
1328 konrad.r 1.6 Sint16 sint16; 1329 //val.set((Sint16)(ar+pos)); 1330 memcpy( &sint16, ar + pos, sizeof(Sint16)); 1331 val.set(sint16);
1332 schuur 1.1 pos+=sizeof(Sint16); 1333 break;
1334 konrad.r 1.7 case CIMTYPE_CHAR16: { 1335 Char16 char16; 1336 memcpy( &char16, ar + pos, sizeof(Char16)); 1337 //val.set((Char16)(ar+pos)); 1338 val.set ( char16 );
1339 schuur 1.1 pos+=sizeof(Char16); 1340 break;
1341 konrad.r 1.7 }
1342 schuur 1.1 case CIMTYPE_UINT32:
1343 konrad.r 1.6 Uint32 uint32; 1344 memcpy ( &uint32, ar + pos, sizeof(Uint32)); 1345 //val.set((Uint32)(ar+pos)); 1346 val.set( uint32 );
1347 schuur 1.1 pos+=sizeof(Uint32); 1348 break; 1349 case CIMTYPE_SINT32:
1350 konrad.r 1.6 Sint32 sint32; 1351 memcpy ( &sint32, ar + pos, sizeof(Sint32)); 1352 //val.set((Sint32)(ar+pos)); 1353 val.set ( sint32 );
1354 schuur 1.1 pos+=sizeof(Sint32); 1355 break; 1356 case CIMTYPE_REAL32:
1357 konrad.r 1.6 Real32 real32; 1358 memcpy ( &real32, ar + pos, sizeof(Real32)); 1359 //val.set((Real32)(ar+pos)); 1360 val.set ( real32 );
1361 schuur 1.1 pos+=sizeof(Real32); 1362 break; 1363 case CIMTYPE_UINT64:
1364 konrad.r 1.6 Uint64 uint64; 1365 memcpy ( &uint64, ar + pos, sizeof(Uint64)); 1366 //val.set((Uint64)(ar+pos)); 1367 val.set( uint64 );
1368 schuur 1.1 pos+=sizeof(Uint64); 1369 break; 1370 case CIMTYPE_SINT64:
1371 konrad.r 1.6 Sint64 sint64; 1372 memcpy( &sint64, ar + pos, sizeof(Sint64)); 1373 //val.set((Sint64)(ar+pos)); 1374 val.set( sint64 );
1375 schuur 1.1 pos+=sizeof(Sint64); 1376 break; 1377 case CIMTYPE_REAL64:
1378 konrad.r 1.6 Real64 real64; 1379 memcpy ( &real64, ar + pos, sizeof(Real64)); 1380 //val.set((Real64)(ar+pos)); 1381 val.set( real64 );
1382 schuur 1.1 pos+=sizeof(Real64); 1383 break; 1384 case CIMTYPE_STRING: {
1385 konrad.r 1.5 Uint32 sl; //=(Uint32)(ar+pos); 1386 memcpy( &sl, ar + pos, sizeof(Uint32));
1387 schuur 1.1 pos+=sizeof(Uint32); 1388 val.set(String(((char*)(ar+pos)),sl)); 1389 pos+=sl; 1390 } 1391 break; 1392 case CIMTYPE_DATETIME: {
1393 konrad.r 1.5 Uint32 dtl; //=(Uint32)(ar+pos); 1394 memcpy( &dtl, ar + pos, sizeof (Uint32));
1395 schuur 1.1 pos+=sizeof(Uint32);
1396 konrad.r 1.7 1397 CIMDateTime time; 1398 #ifdef TYPE_CONV 1399 String string; 1400 string.reserveCapacity(dtl); 1401 1402 for (Uint32 i =0; i < dtlsizeof(Char16); i+=sizeof(Char16)) { 1403 Char16 char_at; 1404 memcpy( &char_at, ar + pos + i, sizeof(Char16)); 1405 string.append( char_at ); 1406 } 1407 time = CIMDateTime ( string ); 1408 #else 1409 time = CIMDateTime(String(((Char16)(ar+pos)),dtl)); 1410 #endif 1411 val.set( time ); 1412 pos+=dtl*sizeof(Char16);
1413 schuur 1.1 } 1414 break; 1415 case CIMTYPE_REFERENCE: {
1416 konrad.r 1.5 Uint32 rfl; //=(Uint32)(ar+pos); 1417 memcpy( &rfl, ar + pos, sizeof (Uint32));
1418 schuur 1.1 pos+=sizeof(Uint32);
1419 konrad.r 1.7 1420 CIMObjectPath objPath; 1421 #ifdef TYPE_CONV 1422 String string; 1423 1424 string.reserveCapacity(rfl); 1425 for (Uint32 i =0; i < rflsizeof(Char16); i+=sizeof(Char16)) { 1426 Char16 char_at; 1427 memcpy ( &char_at, ar + pos +i, sizeof(Char16)); 1428 string.append( char_at ); 1429 } 1430 objPath = CIMObjectPath( string ); 1431 #else 1432 objPath = CIMObjectPath(String(((Char16)(ar+pos)),rfl)); 1433 #endif 1434 val.set( objPath);
1435 schuur 1.1 pos+=rfl*sizeof(Char16); 1436 } 1437 break; 1438 default: 1439 PEGASUS_ASSERT(false); 1440 } 1441 return val; 1442 } 1443 } 1444 else { 1445 CIMValue val; 1446 val.setNullValue(type,isArray,as); 1447 return val; 1448 } 1449 break; 1450 } 1451 default: 1452 throw BinException(BINREP_VALUE,String("CIMValue subtype version ")+ 1453 CIMValue(preamble->version()).toString()+" not supported "); 1454 } 1455 return CIMValue(); 1456 schuur 1.1 } 1457 1458 1459 PEGASUS_NAMESPACE_END

No CVS admin address has been configured