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