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

No CVS admin address has been configured