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