1 martin 1.6 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.7 //
|
3 martin 1.6 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.7 //
|
10 martin 1.6 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.7 //
|
17 martin 1.6 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.7 //
|
20 martin 1.6 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.7 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.6 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.7 //
|
28 martin 1.6 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.1 #include <stdlib.h>
30 #include "Sharable.h"
31 #include "CIMBuffer.h"
32 #include "CIMPropertyRep.h"
33 #include "CIMInstanceRep.h"
34 #include "CIMClassRep.h"
35 #include "CIMQualifierRep.h"
|
36 mike 1.5 #include "CIMQualifierDeclRep.h"
|
37 mike 1.1 #include "CIMParameterRep.h"
38 #include "CIMMethodRep.h"
39 #include "CIMPropertyList.h"
40 #include "CIMParamValueRep.h"
41 #include "CIMKeyBindingRep.h"
42 #include "CIMObjectPathRep.h"
43 #include "CIMPropertyListRep.h"
44 #include "StringRep.h"
|
45 mike 1.2 #include "CIMValueRep.h"
|
46 mike 1.5 #include "StringRep.h"
47 #include "StringInline.h"
48 #include "Buffer.h"
49 #include "BinaryCodec.h"
|
50 mike 1.1
51 #define INSTANCE_MAGIC 0xD6EF2219
52 #define CLASS_MAGIC 0xA8D7DE41
53 #define OBJECT_MAGIC 0xA8D7DE41
54 #define OBJECT_PATH_MAGIC 0x92320710
55 #define PROPERTY_MAGIC 0xBFEAA215
56 #define VALUE_MAGIC 0xE83E360A
57 #define PRESENT_MAGIC 0xF55A7330
58 #define ABSENT_MAGIC 0x77A0A639
59
|
60 mike 1.5 #define FLAG_IS_NULL (1 << 0)
61 #define FLAG_IS_ARRAY (1 << 1)
62 #define FLAG_IS_PROPAGATED (1 << 2)
63 #define FLAG_HAS_CLASS_ORIGIN (1 << 3)
64 #define FLAG_HAS_REFERENCE_CLASS (1 << 4)
65 #define FLAG_HAS_QUALIFIERS (1 << 5)
66
|
67 mike 1.1 PEGASUS_USING_STD;
68
69 PEGASUS_NAMESPACE_BEGIN
70
|
71 mike 1.5 static bool _validString(const Uint16* p, size_t n)
72 {
73 const Uint16* start = p;
74
75 while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
76 {
77 p += 8;
78 n -= 8;
79 }
80
81 while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
82 {
83 p += 4;
84 n -= 4;
85 }
86
87 while (n)
88 {
89 Uint16 c = *p;
90
91 if (c >= 128)
92 mike 1.5 {
93 if (c == 0xFFFE || c == 0xFFFF || (c >= 0xFDD0 && c <= 0xFDEF))
94 return false;
95
96 if (c >= 0xD800 && c <= 0xDBFF)
97 {
98 if (n == 1 || !(p[1] >= 0xDC00 && p[1] <= 0xDFFF))
99 return false;
100 }
101
102 if (c >= 0xDC00 && c <= 0xDFFF)
103 {
104 if (p == start || !(p[-1] >= 0xD800 && p[-1] <= 0xDBFF))
105 return false;
106 }
107 }
108
109 n--;
110 p++;
111 }
112
113 mike 1.5 return true;
114 }
115
116 static inline bool _validName(const String& str)
117 {
118 if (str.size() == 0)
119 return true;
120
121 return CIMName::legal(str);
122 }
123
124 static inline bool _validNamespaceName(const String& str)
125 {
126 if (str.size() == 0)
127 return true;
128
129 return CIMNamespaceName::legal(str);
130 }
131
132 void CIMBuffer::_create(size_t size)
|
133 mike 1.1 {
134 if (size < 1024)
135 size = 1024;
136
|
137 mike 1.3 #if defined(PEGASUS_TEST_VALGRIND)
138 // Valgrind complains that we leave uninitialized bytes in this buffer so
139 _data = (char*)calloc(1, size);
140 #else
|
141 mike 1.1 _data = (char*)malloc(size);
|
142 mike 1.3 #endif
|
143 mike 1.1
|
144 mike 1.5 #if defined(PEGASUS_DEBUG)
145 memset(_data, 0xAA, size);
146 #endif
147
|
148 mike 1.1 if (!_data)
149 {
150 throw PEGASUS_STD(bad_alloc)();
151 }
152
153 _end = _data + size;
154 _ptr = _data;
155 }
156
|
157 mike 1.5 CIMBuffer::CIMBuffer(size_t size) : _swap(0), _validate(0)
158 {
159 _create(size);
160 }
161
162 CIMBuffer::CIMBuffer() : _data(0), _end(0), _ptr(0), _swap(0), _validate(0)
163 {
164 }
165
|
166 mike 1.1 CIMBuffer::~CIMBuffer()
167 {
168 free(_data);
169 }
170
171 void CIMBuffer::_grow(size_t size)
172 {
173 size_t n = _end - _data;
174 size_t m = _ptr - _data;
175 size_t cap = n * 2;
176
|
177 mike 1.5 if (cap <= 4096)
178 cap = 4096;
179
|
180 mike 1.1 // Double the size of the buffer (n * 2). If size is greater than n, then
181 // we will need yet more space so we increment cap by size.
182
183 if (size > n)
184 cap += size;
185
186 _data = (char*)realloc(_data, cap);
187
188 if (!_data)
189 {
190 throw PEGASUS_STD(bad_alloc)();
191 }
192
193 _end = _data + cap;
194 _ptr = _data + m;
|
195 mike 1.5
196 #if defined(PEGASUS_DEBUG)
197 memset(_ptr, 0xAA, _end - _ptr);
198 #elif defined(PEGASUS_TEST_VALGRIND)
|
199 mike 1.3 // Valgrind complains that we leave uninitialized bytes in this buffer so
200 // we clear all newly allocated memory when testing with Valgrind.
201 memset(_ptr, 0, _end - _ptr);
202 #endif
|
203 mike 1.5
|
204 mike 1.1 }
205
206 bool CIMBuffer::getString(String& x)
207 {
208 Uint32 n;
209
210 if (!getUint32(n))
211 return false;
212
213 size_t r = round(n * sizeof(Char16));
214
215 if (_end - _ptr < ptrdiff_t(r))
216 return false;
217
|
218 mike 1.5 if (_swap)
219 {
220 _swapUint16Data((Uint16*)_ptr, n);
221 }
222
223 if (_validate)
224 {
225 if (!_validString((Uint16*)_ptr, n))
226 return false;
227 }
228
|
229 mike 1.1 if (n)
|
230 mike 1.5 x.assign((Char16*)_ptr, n);
231
232 _ptr += r;
233 return true;
234 }
235
236 bool CIMBuffer::getName(CIMName& x)
237 {
238 String tmp;
239
240 if (_validate)
241 {
242 // Get string without validation since we will validate name below.
243
244 _validate = false;
245
246 if (!getString(tmp))
247 return false;
248
249 _validate = true;
250
251 mike 1.5 if (!_validName(tmp))
252 return false;
253 }
254 else
255 {
256 if (!getString(tmp))
257 return false;
258 }
259
260 x = CIMNameCast(tmp);
261 return true;
262 }
263
264 bool CIMBuffer::getNamespaceName(CIMNamespaceName& x)
265 {
266 String tmp;
267
268 if (_validate)
269 {
270 // Get string without validation since we will validate namespace below.
271
272 mike 1.5 _validate = false;
273
274 if (!getString(tmp))
275 return false;
276
277 _validate = true;
278
279 if (!_validNamespaceName(tmp))
280 return false;
281 }
282 else
|
283 mike 1.1 {
|
284 mike 1.5 if (!getString(tmp))
285 return false;
|
286 mike 1.1 }
287
|
288 mike 1.5 x = CIMNamespaceNameCast(tmp);
|
289 mike 1.1 return true;
290 }
291
292 void CIMBuffer::putValue(const CIMValue& x)
293 {
294 CIMValueRep* rep = *((CIMValueRep**)&x);
295
|
296 mike 1.5 // Resolve null flag:
297
298 bool isNull = rep->isNull;
|
299 mike 1.1
|
300 mike 1.5 if (!isNull && rep->type == CIMTYPE_INSTANCE && !rep->isArray)
|
301 mike 1.1 {
302 const CIMInstance& ci = *((CIMInstance*)rep->u._instanceValue);
303
304 if (ci.isUninitialized())
305 {
|
306 mike 1.5 isNull = true;
|
307 mike 1.1 }
308 }
309
|
310 mike 1.5 // Magic:
311 _putMagic(VALUE_MAGIC);
312
313 // Put flags:
314 {
315 Uint32 flags = 0;
316
317 if (isNull)
318 flags |= FLAG_IS_NULL;
319
320 if (rep->isArray)
321 flags |= FLAG_IS_ARRAY;
322
323 putUint32(flags);
324 }
325
326 // Type:
327 putUint32(rep->type);
|
328 mike 1.1
|
329 mike 1.5 if (isNull)
|
330 mike 1.1 return;
331
|
332 mike 1.5 // Put value:
333
|
334 mike 1.1 if (rep->isArray)
335 {
336 switch (rep->type)
337 {
338 case CIMTYPE_BOOLEAN:
|
339 kumpf 1.4 putBooleanA(*(reinterpret_cast<Array<Boolean>*>(&rep->u)));
|
340 mike 1.1 break;
341 case CIMTYPE_UINT8:
|
342 kumpf 1.4 putUint8A(*(reinterpret_cast<Array<Uint8>*>(&rep->u)));
|
343 mike 1.1 break;
344 case CIMTYPE_SINT8:
|
345 kumpf 1.4 putSint8A(*(reinterpret_cast<Array<Sint8>*>(&rep->u)));
|
346 mike 1.1 break;
347 case CIMTYPE_UINT16:
|
348 kumpf 1.4 putUint16A(*(reinterpret_cast<Array<Uint16>*>(&rep->u)));
|
349 mike 1.1 break;
350 case CIMTYPE_SINT16:
|
351 kumpf 1.4 putSint16A(*(reinterpret_cast<Array<Sint16>*>(&rep->u)));
|
352 mike 1.1 break;
353 case CIMTYPE_UINT32:
|
354 kumpf 1.4 putUint32A(*(reinterpret_cast<Array<Uint32>*>(&rep->u)));
|
355 mike 1.1 break;
356 case CIMTYPE_SINT32:
|
357 kumpf 1.4 putSint32A(*(reinterpret_cast<Array<Sint32>*>(&rep->u)));
|
358 mike 1.1 break;
359 case CIMTYPE_UINT64:
|
360 kumpf 1.4 putUint64A(*(reinterpret_cast<Array<Uint64>*>(&rep->u)));
|
361 mike 1.1 break;
362 case CIMTYPE_SINT64:
|
363 kumpf 1.4 putSint64A(*(reinterpret_cast<Array<Sint64>*>(&rep->u)));
|
364 mike 1.1 break;
365 case CIMTYPE_REAL32:
|
366 kumpf 1.4 putReal32A(*(reinterpret_cast<Array<Real32>*>(&rep->u)));
|
367 mike 1.1 break;
368 case CIMTYPE_REAL64:
|
369 kumpf 1.4 putReal64A(*(reinterpret_cast<Array<Real64>*>(&rep->u)));
|
370 mike 1.1 break;
371 case CIMTYPE_CHAR16:
|
372 kumpf 1.4 putChar16A(*(reinterpret_cast<Array<Char16>*>(&rep->u)));
|
373 mike 1.1 break;
374 case CIMTYPE_STRING:
|
375 kumpf 1.4 putStringA(*(reinterpret_cast<Array<String>*>(&rep->u)));
|
376 mike 1.1 break;
377 case CIMTYPE_DATETIME:
|
378 kumpf 1.4 putDateTimeA(*(reinterpret_cast<Array<CIMDateTime>*>(&rep->u)));
|
379 mike 1.1 break;
380 case CIMTYPE_REFERENCE:
|
381 kumpf 1.4 putObjectPathA(
382 *(reinterpret_cast<Array<CIMObjectPath>*>(&rep->u)));
|
383 mike 1.1 break;
384 case CIMTYPE_INSTANCE:
|
385 kumpf 1.8 putInstanceA(*(reinterpret_cast<Array<CIMInstance>*>(&rep->u)),
|
386 mike 1.5 false, false);
|
387 mike 1.1 break;
388 case CIMTYPE_OBJECT:
|
389 mike 1.5 putObjectA(*(reinterpret_cast<Array<CIMObject>*>(&rep->u)),
390 false, false);
|
391 mike 1.1 break;
392 default:
393 PEGASUS_ASSERT(0);
394 break;
395 }
396 }
397 else
398 {
399 switch (rep->type)
400 {
401 case CIMTYPE_BOOLEAN:
402 putBoolean(rep->u._booleanValue);
403 break;
404 case CIMTYPE_UINT8:
405 putUint8(rep->u._uint8Value);
406 break;
407 case CIMTYPE_SINT8:
408 putSint8(rep->u._sint8Value);
409 break;
410 case CIMTYPE_UINT16:
411 putUint16(rep->u._uint16Value);
412 mike 1.1 break;
413 case CIMTYPE_SINT16:
414 putSint16(rep->u._sint16Value);
415 break;
416 case CIMTYPE_UINT32:
417 putUint32(rep->u._uint32Value);
418 break;
419 case CIMTYPE_SINT32:
420 putSint32(rep->u._sint32Value);
421 break;
422 case CIMTYPE_UINT64:
423 putUint64(rep->u._uint64Value);
424 break;
425 case CIMTYPE_SINT64:
426 putSint64(rep->u._sint64Value);
427 break;
428 case CIMTYPE_REAL32:
429 putReal32(rep->u._real32Value);
430 break;
431 case CIMTYPE_REAL64:
432 putReal64(rep->u._real64Value);
433 mike 1.1 break;
434 case CIMTYPE_CHAR16:
435 putChar16(rep->u._char16Value);
436 break;
437 case CIMTYPE_STRING:
438 putString(*((String*)rep->u._stringValue));
439 break;
440 case CIMTYPE_DATETIME:
441 putDateTime(*((CIMDateTime*)rep->u._dateTimeValue));
442 break;
443 case CIMTYPE_REFERENCE:
444 putObjectPath(*((CIMObjectPath*)rep->u._referenceValue));
445 break;
446 case CIMTYPE_INSTANCE:
|
447 mike 1.5 putInstance(*((CIMInstance*)rep->u._instanceValue),false,false);
|
448 mike 1.1 break;
449 case CIMTYPE_OBJECT:
|
450 mike 1.5 putObject(*((CIMObject*)rep->u._instanceValue), false, false);
|
451 mike 1.1 break;
452 default:
453 PEGASUS_ASSERT(0);
454 break;
455 }
456 }
457 }
458
459 bool CIMBuffer::getValue(CIMValue& x)
460 {
461 Uint32 type;
|
462 mike 1.5 Boolean isNull;
|
463 mike 1.1 Boolean isArray;
464
|
465 mike 1.5 // Magic:
|
466 mike 1.1 if (!_testMagic(VALUE_MAGIC))
467 return false;
468
|
469 mike 1.5 // Flags:
470 Uint32 flags;
471
472 if (!getUint32(flags))
473 return false;
474
475 isNull = flags & FLAG_IS_NULL;
476 isArray = flags & FLAG_IS_ARRAY;
477
478 // Type:
479 if (!getUint32(type))
|
480 mike 1.1 return false;
481
482 if (isNull)
483 {
484 x.setNullValue(CIMType(type), isArray, 0);
485 return true;
486 }
487
488 if (isArray)
489 {
490 switch (type)
491 {
492 case CIMTYPE_BOOLEAN:
493 {
494 Array<Boolean> tmp;
495 if (!getBooleanA(tmp))
496 return false;
497 x.set(tmp);
498 return true;
499 }
500 case CIMTYPE_UINT8:
501 mike 1.1 {
502 Array<Uint8> tmp;
503 if (!getUint8A(tmp))
504 return false;
505 x.set(tmp);
506 return true;
507 }
508 case CIMTYPE_SINT8:
509 {
510 Array<Sint8> tmp;
511 if (!getSint8A(tmp))
512 return false;
513 x.set(tmp);
514 return true;
515 }
516 case CIMTYPE_UINT16:
517 {
518 Array<Uint16> tmp;
519 if (!getUint16A(tmp))
520 return false;
521 x.set(tmp);
522 mike 1.1 return true;
523 }
524 case CIMTYPE_SINT16:
525 {
526 Array<Sint16> tmp;
527 if (!getSint16A(tmp))
528 return false;
529 x.set(tmp);
530 return true;
531 }
532 case CIMTYPE_UINT32:
533 {
534 Array<Uint32> tmp;
535 if (!getUint32A(tmp))
536 return false;
537 x.set(tmp);
538 return true;
539 }
540 case CIMTYPE_SINT32:
541 {
542 Array<Sint32> tmp;
543 mike 1.1 if (!getSint32A(tmp))
544 return false;
545 x.set(tmp);
546 return true;
547 }
548 case CIMTYPE_UINT64:
549 {
550 Array<Uint64> tmp;
551 if (!getUint64A(tmp))
552 return false;
553 x.set(tmp);
554 return true;
555 }
556 case CIMTYPE_SINT64:
557 {
558 Array<Sint64> tmp;
559 if (!getSint64A(tmp))
560 return false;
561 x.set(tmp);
562 return true;
563 }
564 mike 1.1 case CIMTYPE_REAL32:
565 {
566 Array<Real32> tmp;
567 if (!getReal32A(tmp))
568 return false;
569 x.set(tmp);
570 return true;
571 }
572 case CIMTYPE_REAL64:
573 {
574 Array<Real64> tmp;
575 if (!getReal64A(tmp))
576 return false;
577 x.set(tmp);
578 return true;
579 }
580 case CIMTYPE_CHAR16:
581 {
582 Array<Char16> tmp;
583 if (!getChar16A(tmp))
584 return false;
585 mike 1.1 x.set(tmp);
586 return true;
587 }
588 case CIMTYPE_STRING:
589 {
590 Array<String> tmp;
591 if (!getStringA(tmp))
592 return false;
593 x.set(tmp);
594 return true;
595 }
596 case CIMTYPE_DATETIME:
597 {
598 Array<CIMDateTime> tmp;
599 if (!getDateTimeA(tmp))
600 return false;
601 x.set(tmp);
602 return true;
603 }
604 case CIMTYPE_REFERENCE:
605 {
606 mike 1.1 Array<CIMObjectPath> tmp;
607 if (!getObjectPathA(tmp))
608 return false;
609 x.set(tmp);
610 return true;
611 }
612 case CIMTYPE_INSTANCE:
613 {
614 Array<CIMInstance> tmp;
615 if (!getInstanceA(tmp))
616 return false;
617 x.set(tmp);
618 return true;
619 }
620 case CIMTYPE_OBJECT:
621 {
622 Array<CIMObject> tmp;
623 if (!getObjectA(tmp))
624 return false;
625 x.set(tmp);
626 return true;
627 mike 1.1 }
628 default:
629 PEGASUS_ASSERT(0);
630 break;
631 }
632 }
633 else
634 {
635 switch (type)
636 {
637 case CIMTYPE_BOOLEAN:
638 {
639 Boolean tmp;
640 if (!getBoolean(tmp))
641 return false;
642 x.set(tmp);
643 return true;
644 }
645 case CIMTYPE_UINT8:
646 {
647 Uint8 tmp;
648 mike 1.1 if (!getUint8(tmp))
649 return false;
650 x.set(tmp);
651 return true;
652 }
653 case CIMTYPE_SINT8:
654 {
655 Sint8 tmp;
656 if (!getSint8(tmp))
657 return false;
658 x.set(tmp);
659 return true;
660 }
661 case CIMTYPE_UINT16:
662 {
663 Uint16 tmp;
664 if (!getUint16(tmp))
665 return false;
666 x.set(tmp);
667 return true;
668 }
669 mike 1.1 case CIMTYPE_SINT16:
670 {
671 Sint16 tmp;
672 if (!getSint16(tmp))
673 return false;
674 x.set(tmp);
675 return true;
676 }
677 case CIMTYPE_UINT32:
678 {
679 Uint32 tmp;
680 if (!getUint32(tmp))
681 return false;
682 x.set(tmp);
683 return true;
684 }
685 case CIMTYPE_SINT32:
686 {
687 Sint32 tmp;
688 if (!getSint32(tmp))
689 return false;
690 mike 1.1 x.set(tmp);
691 return true;
692 }
693 case CIMTYPE_UINT64:
694 {
695 Uint64 tmp;
696 if (!getUint64(tmp))
697 return false;
698 x.set(tmp);
699 return true;
700 }
701 case CIMTYPE_SINT64:
702 {
703 Sint64 tmp;
704 if (!getSint64(tmp))
705 return false;
706 x.set(tmp);
707 return true;
708 }
709 case CIMTYPE_REAL32:
710 {
711 mike 1.1 Real32 tmp;
712 if (!getReal32(tmp))
713 return false;
714 x.set(tmp);
715 return true;
716 }
717 case CIMTYPE_REAL64:
718 {
719 Real64 tmp;
720 if (!getReal64(tmp))
721 return false;
722 x.set(tmp);
723 return true;
724 }
725 case CIMTYPE_CHAR16:
726 {
727 Char16 tmp;
728 if (!getChar16(tmp))
729 return false;
730 x.set(tmp);
731 return true;
732 mike 1.1 }
733 case CIMTYPE_STRING:
734 {
735 String tmp;
736 if (!getString(tmp))
737 return false;
738 x.set(tmp);
739 return true;
740 }
741 case CIMTYPE_DATETIME:
742 {
743 CIMDateTime tmp;
744 if (!getDateTime(tmp))
745 return false;
746 x.set(tmp);
747 return true;
748 }
749 case CIMTYPE_REFERENCE:
750 {
751 CIMObjectPath tmp;
752 if (!getObjectPath(tmp))
753 mike 1.1 return false;
754 x.set(tmp);
755 return true;
756 }
757 case CIMTYPE_INSTANCE:
758 {
759 CIMInstance tmp;
760 if (!getInstance(tmp))
761 return false;
762 x.set(tmp);
763 return true;
764 }
765 case CIMTYPE_OBJECT:
766 {
767 CIMObject tmp;
768 if (!getObject(tmp))
769 return false;
770 x.set(tmp);
771 return true;
772 }
773 default:
774 mike 1.1 PEGASUS_ASSERT(0);
775 break;
776 }
777 }
778
779 // Unreachable!
780 return false;
781 }
782
783 void CIMBuffer::putKeyBinding(const CIMKeyBinding& x)
784 {
785 const CIMKeyBindingRep* kb = *(const CIMKeyBindingRep**)&x;
|
786 mike 1.5 putName(kb->_name);
|
787 mike 1.1 putString(kb->_value);
788 putUint32(kb->_type);
789 }
790
791 bool CIMBuffer::getKeyBinding(CIMKeyBinding& x)
792 {
|
793 mike 1.5 CIMName name;
|
794 mike 1.1 String value;
795 Uint32 type;
796
|
797 mike 1.5 if (!getName(name) || !getString(value) || !getUint32(type))
|
798 mike 1.1 return false;
799
800 x.~CIMKeyBinding();
|
801 mike 1.5 new(&x) CIMKeyBinding(name, value, CIMKeyBinding::Type(type));
|
802 mike 1.1
803 return true;
804 }
805
|
806 mike 1.5 void CIMBuffer::putObjectPath(
|
807 kumpf 1.8 const CIMObjectPath& x,
|
808 mike 1.5 bool includeHostAndNamespace,
809 bool includeKeyBindings)
|
810 mike 1.1 {
811 const CIMObjectPathRep* rep = *((const CIMObjectPathRep**)&x);
812
813 _putMagic(OBJECT_PATH_MAGIC);
814
815 if (x.getClassName().isNull())
816 {
817 putBoolean(false);
818 return;
819 }
820 else
821 putBoolean(true);
822
823
|
824 mike 1.5 if (includeHostAndNamespace)
825 {
826 putString(rep->_host);
827 putNamespaceName(rep->_nameSpace);
828 }
829 else
|
830 mike 1.1 {
|
831 mike 1.5 putString(String());
832 putString(String());
833 }
834
835 putName(rep->_className);
836
837 if (includeKeyBindings)
838 {
839 putUint32(rep->_keyBindings.size());
840
841 for (Uint32 i = 0, n = rep->_keyBindings.size(); i < n; i++)
842 {
843 putKeyBinding(rep->_keyBindings[i]);
844 }
|
845 mike 1.1 }
|
846 mike 1.5 else
847 putUint32(0);
|
848 mike 1.1 }
849
850 bool CIMBuffer::getObjectPath(CIMObjectPath& x)
851 {
852 String host;
|
853 mike 1.5 CIMNamespaceName nameSpace;
854 CIMName className;
|
855 mike 1.1 Uint32 size;
856 Array<CIMKeyBinding> kbs;
857
858 if (!_testMagic(OBJECT_PATH_MAGIC))
859 return false;
860
861 Boolean initialized;
862
863 if (!getBoolean(initialized))
864 return false;
865
866 if (!initialized)
867 {
868 x = CIMObjectPath();
869 return true;
870 }
871
|
872 mike 1.5 if (!getString(host) || !getNamespaceName(nameSpace) || !getName(className))
|
873 mike 1.1 return false;
874
875 if (!getUint32(size))
876 return false;
877
878 for (Uint32 i = 0; i < size; i++)
879 {
880 CIMKeyBinding kb;
881
882 if (!getKeyBinding(kb))
883 return false;
884
885 kbs.append(kb);
886 }
887
|
888 kumpf 1.4 x.set(
889 host,
890 *(reinterpret_cast<CIMNamespaceName*>(&nameSpace)),
|
891 mike 1.5 className,
|
892 kumpf 1.4 kbs);
|
893 mike 1.1
894 return true;
895 }
896
897 void CIMBuffer::putQualifier(const CIMQualifier& x)
898 {
899 const CIMQualifierRep* rep = *((const CIMQualifierRep**)&x);
900
|
901 mike 1.5 putName(rep->_name);
|
902 mike 1.1 putValue(rep->_value);
903 putUint32(*((Uint32*)&rep->_flavor));
904 putBoolean(rep->_propagated);
905 }
906
907 bool CIMBuffer::getQualifier(CIMQualifier& x)
908 {
|
909 mike 1.5 CIMName name;
|
910 mike 1.1 CIMValue value;
911 Uint32 flavor;
912 Boolean propagated;
913
|
914 mike 1.5 if (!getName(name))
|
915 mike 1.1 return false;
916
917 if (!getValue(value))
918 return false;
919
920 if (!getUint32(flavor))
921 return false;
922
923 if (!getBoolean(propagated))
924 return false;
925
926 x.~CIMQualifier();
927
928 new(&x) CIMQualifier(
|
929 mike 1.5 name,
|
930 mike 1.1 value,
|
931 kumpf 1.4 *(reinterpret_cast<CIMFlavor*>(&flavor)),
|
932 mike 1.1 propagated);
933
934 return true;
935 }
936
937 void CIMBuffer::putQualifierList(const CIMQualifierList& x)
938 {
939 Uint32 n = x.getCount();
940 putUint32(n);
941
942 for (Uint32 i = 0; i < n; i++)
943 putQualifier(x.getQualifier(i));
944 }
945
946 bool CIMBuffer::getQualifierList(CIMQualifierList& x)
947 {
948 Uint32 n;
949
950 if (!getUint32(n))
951 return false;
952
953 mike 1.1 for (Uint32 i = 0; i < n; i++)
954 {
955 CIMQualifier tmp;
956
957 if (!getQualifier(tmp))
958 return false;
959
960 x.addUnchecked(tmp);
961 }
962
963 return true;
964 }
965
|
966 mike 1.5 void CIMBuffer::putQualifierDecl(const CIMQualifierDecl& x)
967 {
968 const CIMQualifierDeclRep* rep = *((const CIMQualifierDeclRep**)&x);
969
970 putName(rep->_name);
971 putValue(rep->_value);
972 putUint32(*((Uint32*)&rep->_scope));
973 putUint32(*((Uint32*)&rep->_flavor));
974 putUint32(rep->_arraySize);
975 }
976
977 bool CIMBuffer::getQualifierDecl(CIMQualifierDecl& x)
978 {
979 CIMName name;
980 CIMValue value;
981 Uint32 scope;
982 Uint32 flavor;
983 Uint32 arraySize;
984
985 if (!getName(name))
986 return false;
987 mike 1.5
988 if (!getValue(value))
989 return false;
990
991 if (!getUint32(scope))
992 return false;
993
994 if (!getUint32(flavor))
995 return false;
996
997 if (!getUint32(arraySize))
998 return false;
999
1000 x.~CIMQualifierDecl();
1001
1002 new(&x) CIMQualifierDecl(
1003 name,
1004 value,
1005 *(reinterpret_cast<CIMScope*>(&scope)),
1006 *(reinterpret_cast<CIMFlavor*>(&flavor)),
1007 arraySize);
1008 mike 1.5
1009 return true;
1010 }
1011
|
1012 mike 1.1 void CIMBuffer::putProperty(const CIMProperty& x)
1013 {
1014 const CIMPropertyRep* rep = *((const CIMPropertyRep**)&x);
1015 // PROPERTY_MAGIC
1016 _putMagic(PROPERTY_MAGIC);
1017
|
1018 mike 1.5 // Flags
1019 Uint32 flags = 0;
1020 {
1021 // CIMProperty.arraySize
1022 if (rep->_arraySize)
1023 {
1024 flags |= FLAG_IS_ARRAY;
1025 }
1026
1027 // CIMProperty.referenceClassName
1028 if (rep->_referenceClassName.getString().size())
1029 {
1030 flags |= FLAG_HAS_REFERENCE_CLASS;
1031 }
1032
1033 // CIMProperty.classOrigin
1034 if (rep->_classOrigin.getString().size())
1035 {
1036 flags |= FLAG_HAS_CLASS_ORIGIN;
1037 }
1038
1039 mike 1.5 // CIMProperty.propagated
1040 if (rep->_propagated)
1041 {
1042 flags |= FLAG_IS_PROPAGATED;
1043 }
1044
1045 // CIMProperty.qualifiers
1046 if (rep->_qualifiers.getCount())
1047 {
1048 flags |= FLAG_HAS_QUALIFIERS;
1049 }
1050
1051 putUint32(flags);
1052 }
1053
|
1054 mike 1.1 // CIMProperty.name
|
1055 mike 1.5 putName(rep->_name);
|
1056 mike 1.1
1057 // CIMProperty.value
1058 putValue(rep->_value);
1059
1060 // CIMProperty.arraySize
|
1061 mike 1.5 if (flags & FLAG_IS_ARRAY)
1062 {
1063 putUint32(rep->_arraySize);
1064 }
|
1065 mike 1.1
1066 // CIMProperty.referenceClassName
|
1067 mike 1.5 if (flags & FLAG_HAS_REFERENCE_CLASS)
1068 {
1069 putName(rep->_referenceClassName);
1070 }
|
1071 mike 1.1
1072 // CIMProperty.classOrigin
|
1073 mike 1.5 if (flags & FLAG_HAS_CLASS_ORIGIN)
1074 {
1075 putName(rep->_classOrigin);
1076 }
|
1077 mike 1.1
1078 // CIMProperty.qualifiers
|
1079 mike 1.5 if (flags & FLAG_HAS_QUALIFIERS)
1080 {
1081 putQualifierList(rep->_qualifiers);
1082 flags |= FLAG_HAS_QUALIFIERS;
1083 }
|
1084 mike 1.1 }
1085
1086 bool CIMBuffer::getProperty(CIMProperty& x)
1087 {
|
1088 mike 1.5 CIMName name;
|
1089 mike 1.1 CIMValue value;
1090 Uint32 arraySize;
|
1091 mike 1.5 CIMName referenceClassName;
1092 CIMName classOrigin;
|
1093 mike 1.1 Boolean propagated;
1094
1095 if (!_testMagic(PROPERTY_MAGIC))
1096 return false;
1097
|
1098 mike 1.5 // Flags:
1099 Uint32 flags;
1100
1101 if (!getUint32(flags))
1102 return false;
1103
|
1104 mike 1.1 // CIMProperty.name
|
1105 mike 1.5 if (!getName(name))
|
1106 mike 1.1 return false;
1107
1108 // CIMProperty.value
1109 if (!getValue(value))
1110 return false;
1111
1112 // CIMProperty.arraySize
|
1113 mike 1.5
1114 if (flags & FLAG_IS_ARRAY)
1115 {
1116 if (!getUint32(arraySize))
1117 return false;
1118 }
1119 else
1120 arraySize = 0;
|
1121 mike 1.1
1122 // CIMProperty.referenceClassName
|
1123 mike 1.5
1124 if (flags & FLAG_HAS_REFERENCE_CLASS)
1125 {
1126 if (!getName(referenceClassName))
1127 return false;
1128 }
|
1129 mike 1.1
1130 // CIMProperty.classOrigin
|
1131 mike 1.5
1132 if (flags & FLAG_HAS_CLASS_ORIGIN)
1133 {
1134 if (!getName(classOrigin))
1135 return false;
1136 }
|
1137 mike 1.1
1138 // CIMProperty.propagated
|
1139 mike 1.5 propagated = flags & FLAG_IS_PROPAGATED;
1140
1141 // Create property:
|
1142 mike 1.1
1143 x.~CIMProperty();
1144
1145 new(&x) CIMProperty(
|
1146 mike 1.5 name,
|
1147 mike 1.1 value,
1148 arraySize,
|
1149 mike 1.5 referenceClassName,
1150 classOrigin,
|
1151 mike 1.1 propagated);
1152
1153 CIMPropertyRep* rep = *((CIMPropertyRep**)&x);
1154
1155 // CIMProperty.qualifiers
|
1156 mike 1.5
1157 if (flags & FLAG_HAS_QUALIFIERS)
1158 {
1159 if (!getQualifierList(rep->_qualifiers))
1160 return false;
1161 }
|
1162 mike 1.1
1163 return true;
1164 }
1165
|
1166 mike 1.5 void CIMBuffer::putInstance(
|
1167 kumpf 1.8 const CIMInstance& x,
|
1168 mike 1.5 bool includeHostAndNamespace,
1169 bool includeKeyBindings)
|
1170 mike 1.1 {
1171 const CIMInstanceRep* rep = *((const CIMInstanceRep**)&x);
1172
1173 // INSTANCE_MAGIC:
1174 _putMagic(INSTANCE_MAGIC);
1175
1176 // CIMInstance.initialized:
1177
1178 if (x.isUninitialized())
1179 {
1180 putBoolean(false);
1181 return;
1182 }
1183 else
1184 putBoolean(true);
1185
1186 // CIMInstance.reference:
|
1187 mike 1.5 putObjectPath(rep->_reference, includeHostAndNamespace, includeKeyBindings);
|
1188 mike 1.1
1189 // CIMInstance.qualifiers:
1190 putQualifierList(rep->_qualifiers);
1191
1192 // CIMInstance.properties:
1193 {
1194 Uint32 n = rep->_properties.size();
1195 putUint32(n);
1196
1197 for (Uint32 i = 0; i < n; i++)
1198 putProperty(rep->_properties[i]);
1199 }
1200 }
1201
1202 bool CIMBuffer::getInstance(CIMInstance& x)
1203 {
1204 CIMInstanceRep* rep;
1205
1206 // INSTANCE_MAGIC:
1207
1208 if (!_testMagic(INSTANCE_MAGIC))
1209 mike 1.1 return false;
1210
1211 // initialized:
1212
1213 Boolean initialized;
1214
1215 if (!getBoolean(initialized))
1216 return false;
1217
1218 if (!initialized)
1219 {
1220 x = CIMInstance();
1221 return true;
1222 }
1223
1224 // CIMIntsance.reference:
1225
1226 CIMObjectPath reference;
1227
1228 if (!getObjectPath(reference))
1229 return false;
1230 mike 1.1
1231 rep = new CIMInstanceRep(reference);
1232
1233 // CIMInstance.qualifiers:
1234
1235 if (!getQualifierList(rep->_qualifiers))
1236 return false;
1237
1238 // CIMInstance.properties:
1239 {
1240 Uint32 n;
1241
1242 if (!getUint32(n))
1243 return false;
1244
1245 for (Uint32 i = 0; i < n; i++)
1246 {
1247 CIMProperty tmp;
1248
1249 if (!getProperty(tmp))
1250 {
1251 mike 1.1 return false;
1252 }
1253
1254 rep->_properties.append(tmp);
1255 }
1256 }
1257
1258 // Replace rep:
1259 CIMInstanceRep*& tmp = *((CIMInstanceRep**)&x);
1260
1261 if (tmp)
1262 tmp->Dec();
1263
1264 tmp = rep;
1265
1266 return true;
1267 }
1268
1269 void CIMBuffer::putClass(const CIMClass& x)
1270 {
1271 const CIMClassRep* rep = *((const CIMClassRep**)&x);
1272 mike 1.1
1273 // CLASS_MAGIC:
1274 _putMagic(CLASS_MAGIC);
1275
1276 // CIMClass.initialized:
1277
1278 if (x.isUninitialized())
1279 {
1280 putBoolean(false);
1281 return;
1282 }
1283 else
1284 putBoolean(true);
1285
1286 // CIMInstance.reference:
1287 putObjectPath(rep->_reference);
1288
1289 // CIMClass.superClassName:
|
1290 mike 1.5 putName(rep->_superClassName);
|
1291 mike 1.1
1292 // CIMClass.qualifiers:
1293 putQualifierList(rep->_qualifiers);
1294
1295 // CIMClass.properties:
1296 {
1297 Uint32 n = rep->_properties.size();
1298 putUint32(n);
1299
1300 for (Uint32 i = 0; i < n; i++)
1301 putProperty(rep->_properties[i]);
1302 }
1303
1304 // CIMClass.methods:
1305 {
1306 Uint32 n = rep->_methods.size();
1307 putUint32(n);
1308
1309 for (Uint32 i = 0; i < n; i++)
1310 putMethod(rep->_methods[i]);
1311 }
1312 mike 1.1 }
1313
1314 bool CIMBuffer::getClass(CIMClass& x)
1315 {
1316 CIMClassRep* rep;
|
1317 mike 1.5 CIMName superClassName;
|
1318 mike 1.1
1319 // CLASS_MAGIC:
1320
1321 if (!_testMagic(CLASS_MAGIC))
1322 return false;
1323
1324 // initialized:
1325
1326 Boolean initialized;
1327
1328 if (!getBoolean(initialized))
1329 return false;
1330
1331 if (!initialized)
1332 {
1333 x = CIMClass();
1334 return true;
1335 }
1336
1337 // CIMIntsance.reference:
1338
1339 mike 1.1 CIMObjectPath reference;
1340
1341 if (!getObjectPath(reference))
1342 return false;
1343
1344 // CIMIntsance.superClassName:
1345
|
1346 mike 1.5 if (!getName(superClassName))
|
1347 mike 1.1 return false;
1348
|
1349 kumpf 1.8 rep = new CIMClassRep(reference.getClassName(),
|
1350 mike 1.5 superClassName);
|
1351 mike 1.1
1352 rep->_reference = reference;
1353
1354 // CIMClass.qualifiers:
1355
1356 if (!getQualifierList(rep->_qualifiers))
1357 return false;
1358
1359 // CIMClass.properties:
1360 {
1361 Uint32 n;
1362
1363 if (!getUint32(n))
1364 return false;
1365
1366 for (Uint32 i = 0; i < n; i++)
1367 {
1368 CIMProperty tmp;
1369
1370 if (!getProperty(tmp))
1371 return false;
1372 mike 1.1
1373 rep->_properties.append(tmp);
1374 }
1375 }
1376
1377 // CIMClass.methods:
1378 {
1379 Uint32 n;
1380
1381 if (!getUint32(n))
1382 return false;
1383
1384 for (Uint32 i = 0; i < n; i++)
1385 {
1386 CIMMethod tmp;
1387
1388 if (!getMethod(tmp))
1389 return false;
1390
1391 rep->_methods.append(tmp);
1392 }
1393 mike 1.1 }
1394
1395 // Replace rep:
1396 CIMClassRep*& tmp = *((CIMClassRep**)&x);
1397
1398 if (tmp)
1399 tmp->Dec();
1400
1401 tmp = rep;
1402
1403 return true;
1404 }
1405
1406 void CIMBuffer::putParameter(const CIMParameter& x)
1407 {
1408 const CIMParameterRep* rep = *((const CIMParameterRep**)&x);
1409
1410 // CIMParameter.name
|
1411 mike 1.5 putName(rep->_name);
|
1412 mike 1.1
1413 // CIMParameter.type
1414 putUint32(rep->_type);
1415
1416 // CIMParameter.isArray
1417 putBoolean(rep->_isArray);
1418
1419 // CIMParameter.arraySize
1420 putUint32(rep->_arraySize);
1421
1422 // CIMParameter.referenceClassName
|
1423 mike 1.5 putName(rep->_referenceClassName);
|
1424 mike 1.1
1425 // CIMParameter.qualifiers
1426 putQualifierList(rep->_qualifiers);
1427 }
1428
1429 bool CIMBuffer::getParameter(CIMParameter& x)
1430 {
|
1431 mike 1.5 CIMName name;
|
1432 mike 1.1 Uint32 type;
1433 Boolean isArray;
1434 Uint32 arraySize;
|
1435 mike 1.5 CIMName referenceClassName;
|
1436 mike 1.1
1437 // CIMParameter.name
|
1438 mike 1.5 if (!getName(name))
|
1439 mike 1.1 return false;
1440
1441 // CIMParameter.type
1442 if (!getUint32(type))
1443 return false;
1444
1445 // CIMParameter.isArray
1446 if (!getBoolean(isArray))
1447 return false;
1448
1449 // CIMParameter.arraySize
1450 if (!getUint32(arraySize))
1451 return false;
1452
1453 // CIMParameter.referenceClassName
|
1454 mike 1.5 if (!getName(referenceClassName))
|
1455 mike 1.1 return false;
1456
1457 x.~CIMParameter();
1458
1459 new(&x) CIMParameter(
|
1460 mike 1.5 name,
|
1461 mike 1.1 CIMType(type),
1462 isArray,
1463 arraySize,
|
1464 mike 1.5 referenceClassName);
|
1465 mike 1.1
1466 CIMParameterRep* rep = *((CIMParameterRep**)&x);
1467
1468 // CIMParameter.qualifiers
1469 if (!getQualifierList(rep->_qualifiers))
1470 return false;
1471
1472 return true;
1473 }
1474
1475 void CIMBuffer::putMethod(const CIMMethod& x)
1476 {
1477 const CIMMethodRep* rep = *((const CIMMethodRep**)&x);
1478
1479 // CIMParameter.name
|
1480 mike 1.5 putName(rep->_name);
|
1481 mike 1.1
1482 // CIMParameter.type
1483 putUint32(rep->_type);
1484
1485 // CIMProperty.classOrigin
|
1486 mike 1.5 putName(rep->_classOrigin);
|
1487 mike 1.1
1488 // CIMProperty.propagated
1489 putBoolean(rep->_propagated);
1490
1491 // CIMMethod.qualifiers:
1492 putQualifierList(rep->_qualifiers);
1493
1494 // CIMMethod.parameters:
1495 {
1496 Uint32 n = rep->_parameters.size();
1497 putUint32(n);
1498
1499 for (Uint32 i = 0; i < n; i++)
1500 putParameter(rep->_parameters[i]);
1501 }
1502 }
1503
1504 bool CIMBuffer::getMethod(CIMMethod& x)
1505 {
1506 CIMMethodRep* rep;
|
1507 mike 1.5 CIMName name;
|
1508 mike 1.1 Uint32 type;
|
1509 mike 1.5 CIMName classOrigin;
|
1510 mike 1.1 Boolean propagated;
1511
1512 // CIMMethod.name
|
1513 mike 1.5 if (!getName(name))
|
1514 mike 1.1 return false;
1515
1516 // CIMMethod.type
1517 if (!getUint32(type))
1518 return false;
1519
1520 // CIMParameter.classOrigin
|
1521 mike 1.5 if (!getName(classOrigin))
|
1522 mike 1.1 return false;
1523
1524 // CIMParameter.propagated
1525 if (!getBoolean(propagated))
1526 return false;
1527
|
1528 mike 1.5 rep = new CIMMethodRep(
1529 name, CIMType(type), classOrigin, propagated);
|
1530 mike 1.1
1531 // CIMMethod.qualifiers:
1532 if (!getQualifierList(rep->_qualifiers))
1533 return false;
1534
1535 // CIMMethod.parameters:
1536 {
1537 Uint32 n;
1538
1539 if (!getUint32(n))
1540 return false;
1541
1542 for (Uint32 i = 0; i < n; i++)
1543 {
1544 CIMParameter tmp;
1545
1546 if (!getParameter(tmp))
1547 return false;
1548
1549 rep->_parameters.append(tmp);
1550 }
1551 mike 1.1 }
1552
1553 // Replace rep:
1554
1555 CIMMethodRep*& tmp = *((CIMMethodRep**)&x);
1556
1557 if (tmp)
1558 tmp->Dec();
1559
1560 tmp = rep;
1561
1562 return true;
1563 }
1564
1565 void CIMBuffer::putPropertyList(const CIMPropertyList& x)
1566 {
1567 CIMPropertyListRep* rep = *((CIMPropertyListRep**)&x);
1568
1569 putBoolean(rep->isNull);
1570
1571 if (!rep->isNull)
1572 mike 1.1 {
1573 Uint32 n = rep->propertyNames.size();
1574 putUint32(n);
1575
1576 for (Uint32 i = 0; i < n; i++)
|
1577 mike 1.5 putName(rep->propertyNames[i]);
|
1578 mike 1.1 }
1579 }
1580
1581 bool CIMBuffer::getPropertyList(CIMPropertyList& x)
1582 {
1583 Boolean isNull;
1584
1585 if (!getBoolean(isNull))
1586 return false;
1587
1588 if (isNull)
1589 {
1590 x.~CIMPropertyList();
1591 new(&x) CIMPropertyList();
1592 }
1593 else
1594 {
1595 Array<CIMName> names;
1596
1597 Uint32 n;
1598
1599 mike 1.1 if (!getUint32(n))
1600 return false;
1601
1602 for (Uint32 i = 0; i < n; i++)
1603 {
|
1604 mike 1.5 CIMName name;
|
1605 mike 1.1
|
1606 mike 1.5 if (!getName(name))
|
1607 mike 1.1 return false;
1608
|
1609 mike 1.5 names.append(name);
|
1610 mike 1.1 }
1611
1612 x.~CIMPropertyList();
1613 new(&x) CIMPropertyList(names);
1614 }
1615
1616 return true;
1617 }
1618
|
1619 mike 1.5 void CIMBuffer::putObject(
1620 const CIMObject& x,
1621 bool includeHostAndNamespace,
1622 bool includeKeyBindings)
|
1623 mike 1.1 {
1624 _putMagic(OBJECT_MAGIC);
1625
1626 if (x.isUninitialized())
1627 {
1628 putBoolean(false);
1629 return;
1630 }
1631 else
1632 putBoolean(true);
1633
1634 if (x.isInstance())
1635 {
1636 putUint8('I');
|
1637 mike 1.5 putInstance(
1638 CIMInstance(x), includeHostAndNamespace, includeKeyBindings);
|
1639 mike 1.1 }
1640 else
1641 {
1642 putUint8('C');
1643 putClass(CIMClass(x));
1644 }
1645 }
1646
1647 bool CIMBuffer::getObject(CIMObject& x)
1648 {
1649 Boolean initialized;
1650 Uint8 tag;
1651
1652 if (!_testMagic(OBJECT_MAGIC))
1653 return false;
1654
1655 if (!getBoolean(initialized))
1656 return false;
1657
1658 if (!initialized)
1659 {
1660 mike 1.1 x = CIMObject();
1661 return true;
1662 }
1663
1664 if (!getUint8(tag))
1665 return false;
1666
1667 if (tag == 'I')
1668 {
1669 CIMInstance tmp;
1670
1671 if (!getInstance(tmp))
1672 return false;
1673
1674 x.~CIMObject();
1675 new(&x) CIMObject(tmp);
1676 return true;
1677 }
1678 else if (tag == 'C')
1679 {
1680 CIMClass tmp;
1681 mike 1.1
1682 if (!getClass(tmp))
1683 return false;
1684
1685 x.~CIMObject();
1686 new(&x) CIMObject(tmp);
1687 return true;
1688 }
1689 else
1690 return false;
1691
1692 }
1693
1694 void CIMBuffer::putParamValue(const CIMParamValue& x)
1695 {
1696 const CIMParamValueRep* rep = *((const CIMParamValueRep**)&x);
1697
1698 // CIMParamValue.parameterName:
1699 putString(rep->_parameterName);
1700
1701 // CIMParamValue.value:
1702 mike 1.1 putValue(rep->_value);
1703
1704 // CIMParamValue.isTyped:
1705 putBoolean(rep->_isTyped);
1706 }
1707
1708 bool CIMBuffer::getParamValue(CIMParamValue& x)
1709 {
1710 String parameterName;
1711 CIMValue value;
1712 Boolean isTyped;
1713
1714 // CIMParamValue.parameterName:
1715 if (!getString(parameterName))
1716 return false;
1717
1718 // CIMParamValue.value:
1719 if (!getValue(value))
1720 return false;
1721
1722 // CIMParamValue.isTyped:
1723 mike 1.1 if (!getBoolean(isTyped))
1724 return false;
1725
1726 x.~CIMParamValue();
1727 new(&x) CIMParamValue(parameterName, value, isTyped);
1728
1729 return true;
1730 }
1731
1732 void CIMBuffer::putPresent(Boolean flag)
1733 {
1734 if (flag)
1735 putUint32(PRESENT_MAGIC);
1736 else
1737 putUint32(ABSENT_MAGIC);
1738 }
1739
1740 bool CIMBuffer::getPresent(Boolean& flag)
1741 {
1742 Uint32 tmp;
1743
1744 mike 1.1 if (!getUint32(tmp))
1745 return false;
1746
1747 if (tmp == PRESENT_MAGIC)
1748 {
1749 flag = true;
1750 return true;
1751 }
1752 else if (tmp == ABSENT_MAGIC)
1753 {
1754 flag = false;
1755 return true;
1756 }
1757
1758 return false;
1759 }
1760
|
1761 mike 1.5 void CIMBuffer::putInstanceA(
|
1762 kumpf 1.8 const Array<CIMInstance>& x,
|
1763 mike 1.5 bool includeHostAndNamespace,
1764 bool includeKeyBindings)
1765 {
1766 Uint32 n = x.size();
1767 putUint32(n);
1768
1769 for (size_t i = 0; i < n; i++)
1770 putInstance(x[i], includeHostAndNamespace, includeKeyBindings);
1771 }
1772
|
1773 mike 1.1 PEGASUS_NAMESPACE_END
|
Return to
CIMBuffer.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common