1 mike 1.1 #include <stdlib.h>
2 #include "Sharable.h"
3 #include "CIMBuffer.h"
4 #include "CIMPropertyRep.h"
5 #include "CIMInstanceRep.h"
6 #include "CIMClassRep.h"
7 #include "CIMQualifierRep.h"
8 #include "CIMParameterRep.h"
9 #include "CIMMethodRep.h"
10 #include "CIMPropertyList.h"
11 #include "CIMParamValueRep.h"
12 #include "CIMKeyBindingRep.h"
13 #include "CIMObjectPathRep.h"
14 #include "CIMPropertyListRep.h"
15 #include "StringRep.h"
16
17 #define INSTANCE_MAGIC 0xD6EF2219
18 #define CLASS_MAGIC 0xA8D7DE41
19 #define OBJECT_MAGIC 0xA8D7DE41
20 #define OBJECT_PATH_MAGIC 0x92320710
21 #define PROPERTY_MAGIC 0xBFEAA215
22 mike 1.1 #define VALUE_MAGIC 0xE83E360A
23 #define PRESENT_MAGIC 0xF55A7330
24 #define ABSENT_MAGIC 0x77A0A639
25
26 PEGASUS_USING_STD;
27
28 PEGASUS_NAMESPACE_BEGIN
29
30 CIMBuffer::CIMBuffer(size_t size)
31 {
32 if (size < 1024)
33 size = 1024;
34
35 _data = (char*)malloc(size);
36
37 if (!_data)
38 {
39 throw PEGASUS_STD(bad_alloc)();
40 }
41
42 _end = _data + size;
43 mike 1.1 _ptr = _data;
44 }
45
46 CIMBuffer::~CIMBuffer()
47 {
48 free(_data);
49 }
50
51 void CIMBuffer::_grow(size_t size)
52 {
53 size_t n = _end - _data;
54 size_t m = _ptr - _data;
55 size_t cap = n * 2;
56
57 // Double the size of the buffer (n * 2). If size is greater than n, then
58 // we will need yet more space so we increment cap by size.
59
60 if (size > n)
61 cap += size;
62
63 _data = (char*)realloc(_data, cap);
64 mike 1.1
65 if (!_data)
66 {
67 throw PEGASUS_STD(bad_alloc)();
68 }
69
70 _end = _data + cap;
71 _ptr = _data + m;
72 }
73
74 bool CIMBuffer::getString(String& x)
75 {
76 Uint32 n;
77
78 if (!getUint32(n))
79 return false;
80
81 size_t r = round(n * sizeof(Char16));
82
83 if (_end - _ptr < ptrdiff_t(r))
84 return false;
85 mike 1.1
86 if (n)
87 {
88 x.assign((Char16*)_ptr, n);
89 }
90
91 _ptr += r;
92 return true;
93 }
94
95 void CIMBuffer::putValue(const CIMValue& x)
96 {
97 #if defined(PEGASUS_USE_EMBEDDED_VALUES)
98 CIMValueRep* rep = ((CIMValueRep*)&x);
99 #else
100 CIMValueRep* rep = *((CIMValueRep**)&x);
101 #endif
102
103 _putMagic(VALUE_MAGIC);
104 putUint32(rep->type);
105 putBoolean(rep->isArray);
106 mike 1.1
107 if (rep->type == CIMTYPE_INSTANCE && !rep->isArray)
108 {
109 const CIMInstance& ci = *((CIMInstance*)rep->u._instanceValue);
110
111 if (ci.isUninitialized())
112 {
113 putBoolean(rep->isNull);
114 return;
115 }
116 }
117
118 putBoolean(rep->isNull);
119
120 if (rep->isNull)
121 return;
122
123 if (rep->isArray)
124 {
125 switch (rep->type)
126 {
127 mike 1.1 case CIMTYPE_BOOLEAN:
128 putBooleanA(*((Array<Boolean>*)&rep->u));
129 break;
130 case CIMTYPE_UINT8:
131 putUint8A(*((Array<Uint8>*)&rep->u));
132 break;
133 case CIMTYPE_SINT8:
134 putSint8A(*((Array<Sint8>*)&rep->u));
135 break;
136 case CIMTYPE_UINT16:
137 putUint16A(*((Array<Uint16>*)&rep->u));
138 break;
139 case CIMTYPE_SINT16:
140 putSint16A(*((Array<Sint16>*)&rep->u));
141 break;
142 case CIMTYPE_UINT32:
143 putUint32A(*((Array<Uint32>*)&rep->u));
144 break;
145 case CIMTYPE_SINT32:
146 putSint32A(*((Array<Sint32>*)&rep->u));
147 break;
148 mike 1.1 case CIMTYPE_UINT64:
149 putUint64A(*((Array<Uint64>*)&rep->u));
150 break;
151 case CIMTYPE_SINT64:
152 putSint64A(*((Array<Sint64>*)&rep->u));
153 break;
154 case CIMTYPE_REAL32:
155 putReal32A(*((Array<Real32>*)&rep->u));
156 break;
157 case CIMTYPE_REAL64:
158 putReal64A(*((Array<Real64>*)&rep->u));
159 break;
160 case CIMTYPE_CHAR16:
161 putChar16A(*((Array<Char16>*)&rep->u));
162 break;
163 case CIMTYPE_STRING:
164 putStringA(*((Array<String>*)&rep->u));
165 break;
166 case CIMTYPE_DATETIME:
167 putDateTimeA(*((Array<CIMDateTime>*)&rep->u));
168 break;
169 mike 1.1 case CIMTYPE_REFERENCE:
170 putObjectPathA(*((Array<CIMObjectPath>*)&rep->u));
171 break;
172 case CIMTYPE_INSTANCE:
173 putInstanceA(*((Array<CIMInstance>*)&rep->u));
174 break;
175 case CIMTYPE_OBJECT:
176 putObjectA(*((Array<CIMObject>*)&rep->u));
177 break;
178 default:
179 PEGASUS_ASSERT(0);
180 break;
181 }
182 }
183 else
184 {
185 switch (rep->type)
186 {
187 case CIMTYPE_BOOLEAN:
188 putBoolean(rep->u._booleanValue);
189 break;
190 mike 1.1 case CIMTYPE_UINT8:
191 putUint8(rep->u._uint8Value);
192 break;
193 case CIMTYPE_SINT8:
194 putSint8(rep->u._sint8Value);
195 break;
196 case CIMTYPE_UINT16:
197 putUint16(rep->u._uint16Value);
198 break;
199 case CIMTYPE_SINT16:
200 putSint16(rep->u._sint16Value);
201 break;
202 case CIMTYPE_UINT32:
203 putUint32(rep->u._uint32Value);
204 break;
205 case CIMTYPE_SINT32:
206 putSint32(rep->u._sint32Value);
207 break;
208 case CIMTYPE_UINT64:
209 putUint64(rep->u._uint64Value);
210 break;
211 mike 1.1 case CIMTYPE_SINT64:
212 putSint64(rep->u._sint64Value);
213 break;
214 case CIMTYPE_REAL32:
215 putReal32(rep->u._real32Value);
216 break;
217 case CIMTYPE_REAL64:
218 putReal64(rep->u._real64Value);
219 break;
220 case CIMTYPE_CHAR16:
221 putChar16(rep->u._char16Value);
222 break;
223 case CIMTYPE_STRING:
224 putString(*((String*)rep->u._stringValue));
225 break;
226 case CIMTYPE_DATETIME:
227 putDateTime(*((CIMDateTime*)rep->u._dateTimeValue));
228 break;
229 case CIMTYPE_REFERENCE:
230 putObjectPath(*((CIMObjectPath*)rep->u._referenceValue));
231 break;
232 mike 1.1 case CIMTYPE_INSTANCE:
233 putInstance(*((CIMInstance*)rep->u._instanceValue));
234 break;
235 case CIMTYPE_OBJECT:
236 putObject(*((CIMObject*)rep->u._instanceValue));
237 break;
238 default:
239 PEGASUS_ASSERT(0);
240 break;
241 }
242 }
243 }
244
245 bool CIMBuffer::getValue(CIMValue& x)
246 {
247 Uint32 type;
248 Boolean isArray;
249 Boolean isNull;
250
251 if (!_testMagic(VALUE_MAGIC))
252 return false;
253 mike 1.1
254 if (!getUint32(type) || !getBoolean(isArray) || !getBoolean(isNull))
255 return false;
256
257 if (isNull)
258 {
259 x.setNullValue(CIMType(type), isArray, 0);
260 return true;
261 }
262
263 if (isArray)
264 {
265 switch (type)
266 {
267 case CIMTYPE_BOOLEAN:
268 {
269 Array<Boolean> tmp;
270 if (!getBooleanA(tmp))
271 return false;
272 x.set(tmp);
273 return true;
274 mike 1.1 }
275 case CIMTYPE_UINT8:
276 {
277 Array<Uint8> tmp;
278 if (!getUint8A(tmp))
279 return false;
280 x.set(tmp);
281 return true;
282 }
283 case CIMTYPE_SINT8:
284 {
285 Array<Sint8> tmp;
286 if (!getSint8A(tmp))
287 return false;
288 x.set(tmp);
289 return true;
290 }
291 case CIMTYPE_UINT16:
292 {
293 Array<Uint16> tmp;
294 if (!getUint16A(tmp))
295 mike 1.1 return false;
296 x.set(tmp);
297 return true;
298 }
299 case CIMTYPE_SINT16:
300 {
301 Array<Sint16> tmp;
302 if (!getSint16A(tmp))
303 return false;
304 x.set(tmp);
305 return true;
306 }
307 case CIMTYPE_UINT32:
308 {
309 Array<Uint32> tmp;
310 if (!getUint32A(tmp))
311 return false;
312 x.set(tmp);
313 return true;
314 }
315 case CIMTYPE_SINT32:
316 mike 1.1 {
317 Array<Sint32> tmp;
318 if (!getSint32A(tmp))
319 return false;
320 x.set(tmp);
321 return true;
322 }
323 case CIMTYPE_UINT64:
324 {
325 Array<Uint64> tmp;
326 if (!getUint64A(tmp))
327 return false;
328 x.set(tmp);
329 return true;
330 }
331 case CIMTYPE_SINT64:
332 {
333 Array<Sint64> tmp;
334 if (!getSint64A(tmp))
335 return false;
336 x.set(tmp);
337 mike 1.1 return true;
338 }
339 case CIMTYPE_REAL32:
340 {
341 Array<Real32> tmp;
342 if (!getReal32A(tmp))
343 return false;
344 x.set(tmp);
345 return true;
346 }
347 case CIMTYPE_REAL64:
348 {
349 Array<Real64> tmp;
350 if (!getReal64A(tmp))
351 return false;
352 x.set(tmp);
353 return true;
354 }
355 case CIMTYPE_CHAR16:
356 {
357 Array<Char16> tmp;
358 mike 1.1 if (!getChar16A(tmp))
359 return false;
360 x.set(tmp);
361 return true;
362 }
363 case CIMTYPE_STRING:
364 {
365 Array<String> tmp;
366 if (!getStringA(tmp))
367 return false;
368 x.set(tmp);
369 return true;
370 }
371 case CIMTYPE_DATETIME:
372 {
373 Array<CIMDateTime> tmp;
374 if (!getDateTimeA(tmp))
375 return false;
376 x.set(tmp);
377 return true;
378 }
379 mike 1.1 case CIMTYPE_REFERENCE:
380 {
381 Array<CIMObjectPath> tmp;
382 if (!getObjectPathA(tmp))
383 return false;
384 x.set(tmp);
385 return true;
386 }
387 case CIMTYPE_INSTANCE:
388 {
389 Array<CIMInstance> tmp;
390 if (!getInstanceA(tmp))
391 return false;
392 x.set(tmp);
393 return true;
394 }
395 case CIMTYPE_OBJECT:
396 {
397 Array<CIMObject> tmp;
398 if (!getObjectA(tmp))
399 return false;
400 mike 1.1 x.set(tmp);
401 return true;
402 }
403 default:
404 PEGASUS_ASSERT(0);
405 break;
406 }
407 }
408 else
409 {
410 switch (type)
411 {
412 case CIMTYPE_BOOLEAN:
413 {
414 Boolean tmp;
415 if (!getBoolean(tmp))
416 return false;
417 x.set(tmp);
418 return true;
419 }
420 case CIMTYPE_UINT8:
421 mike 1.1 {
422 Uint8 tmp;
423 if (!getUint8(tmp))
424 return false;
425 x.set(tmp);
426 return true;
427 }
428 case CIMTYPE_SINT8:
429 {
430 Sint8 tmp;
431 if (!getSint8(tmp))
432 return false;
433 x.set(tmp);
434 return true;
435 }
436 case CIMTYPE_UINT16:
437 {
438 Uint16 tmp;
439 if (!getUint16(tmp))
440 return false;
441 x.set(tmp);
442 mike 1.1 return true;
443 }
444 case CIMTYPE_SINT16:
445 {
446 Sint16 tmp;
447 if (!getSint16(tmp))
448 return false;
449 x.set(tmp);
450 return true;
451 }
452 case CIMTYPE_UINT32:
453 {
454 Uint32 tmp;
455 if (!getUint32(tmp))
456 return false;
457 x.set(tmp);
458 return true;
459 }
460 case CIMTYPE_SINT32:
461 {
462 Sint32 tmp;
463 mike 1.1 if (!getSint32(tmp))
464 return false;
465 x.set(tmp);
466 return true;
467 }
468 case CIMTYPE_UINT64:
469 {
470 Uint64 tmp;
471 if (!getUint64(tmp))
472 return false;
473 x.set(tmp);
474 return true;
475 }
476 case CIMTYPE_SINT64:
477 {
478 Sint64 tmp;
479 if (!getSint64(tmp))
480 return false;
481 x.set(tmp);
482 return true;
483 }
484 mike 1.1 case CIMTYPE_REAL32:
485 {
486 Real32 tmp;
487 if (!getReal32(tmp))
488 return false;
489 x.set(tmp);
490 return true;
491 }
492 case CIMTYPE_REAL64:
493 {
494 Real64 tmp;
495 if (!getReal64(tmp))
496 return false;
497 x.set(tmp);
498 return true;
499 }
500 case CIMTYPE_CHAR16:
501 {
502 Char16 tmp;
503 if (!getChar16(tmp))
504 return false;
505 mike 1.1 x.set(tmp);
506 return true;
507 }
508 case CIMTYPE_STRING:
509 {
510 String tmp;
511 if (!getString(tmp))
512 return false;
513 x.set(tmp);
514 return true;
515 }
516 case CIMTYPE_DATETIME:
517 {
518 CIMDateTime tmp;
519 if (!getDateTime(tmp))
520 return false;
521 x.set(tmp);
522 return true;
523 }
524 case CIMTYPE_REFERENCE:
525 {
526 mike 1.1 CIMObjectPath tmp;
527 if (!getObjectPath(tmp))
528 return false;
529 x.set(tmp);
530 return true;
531 }
532 case CIMTYPE_INSTANCE:
533 {
534 CIMInstance tmp;
535 if (!getInstance(tmp))
536 return false;
537 x.set(tmp);
538 return true;
539 }
540 case CIMTYPE_OBJECT:
541 {
542 CIMObject tmp;
543 if (!getObject(tmp))
544 return false;
545 x.set(tmp);
546 return true;
547 mike 1.1 }
548 default:
549 PEGASUS_ASSERT(0);
550 break;
551 }
552 }
553
554 // Unreachable!
555 return false;
556 }
557
558 void CIMBuffer::putKeyBinding(const CIMKeyBinding& x)
559 {
560 const CIMKeyBindingRep* kb = *(const CIMKeyBindingRep**)&x;
561 putString(kb->_name.getString());
562 putString(kb->_value);
563 putUint32(kb->_type);
564 }
565
566 bool CIMBuffer::getKeyBinding(CIMKeyBinding& x)
567 {
568 mike 1.1 String name;
569 String value;
570 Uint32 type;
571
572 if (!getString(name) || !getString(value) || !getUint32(type))
573 return false;
574
575 x.~CIMKeyBinding();
576 new(&x) CIMKeyBinding(_CIMNameCast(name), value, CIMKeyBinding::Type(type));
577
578 return true;
579 }
580
581 void CIMBuffer::putObjectPath(const CIMObjectPath& x)
582 {
583 const CIMObjectPathRep* rep = *((const CIMObjectPathRep**)&x);
584
585 _putMagic(OBJECT_PATH_MAGIC);
586
587 if (x.getClassName().isNull())
588 {
589 mike 1.1 putBoolean(false);
590 return;
591 }
592 else
593 putBoolean(true);
594
595 putString(rep->_host);
596 putString(rep->_nameSpace.getString());
597 putString(rep->_className.getString());
598 putUint32(rep->_keyBindings.size());
599
600 for (Uint32 i = 0, n = rep->_keyBindings.size(); i < n; i++)
601 {
602 putKeyBinding(rep->_keyBindings[i]);
603 }
604 }
605
606 bool CIMBuffer::getObjectPath(CIMObjectPath& x)
607 {
608 String host;
609 String nameSpace;
610 mike 1.1 String className;
611 Uint32 size;
612 Array<CIMKeyBinding> kbs;
613
614 if (!_testMagic(OBJECT_PATH_MAGIC))
615 return false;
616
617 Boolean initialized;
618
619 if (!getBoolean(initialized))
620 return false;
621
622 if (!initialized)
623 {
624 x = CIMObjectPath();
625 return true;
626 }
627
628 if (!getString(host) || !getString(nameSpace) || !getString(className))
629 return false;
630
631 mike 1.1 if (!getUint32(size))
632 return false;
633
634 for (Uint32 i = 0; i < size; i++)
635 {
636 CIMKeyBinding kb;
637
638 if (!getKeyBinding(kb))
639 return false;
640
641 kbs.append(kb);
642 }
643
644 x.set(host, *((CIMNamespaceName*)&nameSpace), _CIMNameCast(className), kbs);
645
646 return true;
647 }
648
649 void CIMBuffer::putQualifier(const CIMQualifier& x)
650 {
651 const CIMQualifierRep* rep = *((const CIMQualifierRep**)&x);
652 mike 1.1
653 putString(rep->_name.getString());
654 putValue(rep->_value);
655 putUint32(*((Uint32*)&rep->_flavor));
656 putBoolean(rep->_propagated);
657 }
658
659 bool CIMBuffer::getQualifier(CIMQualifier& x)
660 {
661 String name;
662 CIMValue value;
663 Uint32 flavor;
664 Boolean propagated;
665
666 if (!getString(name))
667 return false;
668
669 if (!getValue(value))
670 return false;
671
672 if (!getUint32(flavor))
673 mike 1.1 return false;
674
675 if (!getBoolean(propagated))
676 return false;
677
678 x.~CIMQualifier();
679
680 new(&x) CIMQualifier(
681 _CIMNameCast(name),
682 value,
683 *((CIMFlavor*)&flavor),
684 propagated);
685
686 return true;
687 }
688
689 void CIMBuffer::putQualifierList(const CIMQualifierList& x)
690 {
691 Uint32 n = x.getCount();
692 putUint32(n);
693
694 mike 1.1 for (Uint32 i = 0; i < n; i++)
695 putQualifier(x.getQualifier(i));
696 }
697
698 bool CIMBuffer::getQualifierList(CIMQualifierList& x)
699 {
700 Uint32 n;
701
702 if (!getUint32(n))
703 return false;
704
705 for (Uint32 i = 0; i < n; i++)
706 {
707 CIMQualifier tmp;
708
709 if (!getQualifier(tmp))
710 return false;
711
712 x.addUnchecked(tmp);
713 }
714
715 mike 1.1 return true;
716 }
717
718 void CIMBuffer::putProperty(const CIMProperty& x)
719 {
720 const CIMPropertyRep* rep = *((const CIMPropertyRep**)&x);
721
722 // PROPERTY_MAGIC
723 _putMagic(PROPERTY_MAGIC);
724
725 // CIMProperty.name
726 putString(rep->_name.getString());
727
728 // CIMProperty.value
729 putValue(rep->_value);
730
731 // CIMProperty.arraySize
732 putUint32(rep->_arraySize);
733
734 // CIMProperty.referenceClassName
735 putString(rep->_referenceClassName.getString());
736 mike 1.1
737 // CIMProperty.classOrigin
738 putString(rep->_classOrigin.getString());
739
740 // CIMProperty.propagated
741 putBoolean(rep->_propagated);
742
743 // CIMProperty.qualifiers
744 putQualifierList(rep->_qualifiers);
745 }
746
747 bool CIMBuffer::getProperty(CIMProperty& x)
748 {
749 String name;
750 CIMValue value;
751 Uint32 arraySize;
752 String referenceClassName;
753 String classOrigin;
754 Boolean propagated;
755
756 if (!_testMagic(PROPERTY_MAGIC))
757 mike 1.1 return false;
758
759 // CIMProperty.name
760 if (!getString(name))
761 return false;
762
763 // CIMProperty.value
764 if (!getValue(value))
765 return false;
766
767 // CIMProperty.arraySize
768 if (!getUint32(arraySize))
769 return false;
770
771 // CIMProperty.referenceClassName
772 if (!getString(referenceClassName))
773 return false;
774
775 // CIMProperty.classOrigin
776 if (!getString(classOrigin))
777 return false;
778 mike 1.1
779 // CIMProperty.propagated
780 if (!getBoolean(propagated))
781 return false;
782
783 x.~CIMProperty();
784
785 new(&x) CIMProperty(
786 _CIMNameCast(name),
787 value,
788 arraySize,
789 _CIMNameCast(referenceClassName),
790 _CIMNameCast(classOrigin),
791 propagated);
792
793 CIMPropertyRep* rep = *((CIMPropertyRep**)&x);
794
795 // CIMProperty.qualifiers
796 if (!getQualifierList(rep->_qualifiers))
797 return false;
798
799 mike 1.1 return true;
800 }
801
802 void CIMBuffer::putInstance(const CIMInstance& x)
803 {
804 const CIMInstanceRep* rep = *((const CIMInstanceRep**)&x);
805
806 // INSTANCE_MAGIC:
807 _putMagic(INSTANCE_MAGIC);
808
809 // CIMInstance.initialized:
810
811 if (x.isUninitialized())
812 {
813 putBoolean(false);
814 return;
815 }
816 else
817 putBoolean(true);
818
819 // CIMInstance.reference:
820 mike 1.1 putObjectPath(rep->_reference);
821
822 // CIMInstance.qualifiers:
823 putQualifierList(rep->_qualifiers);
824
825 // CIMInstance.properties:
826 {
827 Uint32 n = rep->_properties.size();
828 putUint32(n);
829
830 for (Uint32 i = 0; i < n; i++)
831 putProperty(rep->_properties[i]);
832 }
833 }
834
835 bool CIMBuffer::getInstance(CIMInstance& x)
836 {
837 CIMInstanceRep* rep;
838
839 // INSTANCE_MAGIC:
840
841 mike 1.1 if (!_testMagic(INSTANCE_MAGIC))
842 return false;
843
844 // initialized:
845
846 Boolean initialized;
847
848 if (!getBoolean(initialized))
849 return false;
850
851 if (!initialized)
852 {
853 x = CIMInstance();
854 return true;
855 }
856
857 // CIMIntsance.reference:
858
859 CIMObjectPath reference;
860
861 if (!getObjectPath(reference))
862 mike 1.1 return false;
863
864 rep = new CIMInstanceRep(reference);
865
866 // CIMInstance.qualifiers:
867
868 if (!getQualifierList(rep->_qualifiers))
869 return false;
870
871 // CIMInstance.properties:
872 {
873 Uint32 n;
874
875 if (!getUint32(n))
876 return false;
877
878 for (Uint32 i = 0; i < n; i++)
879 {
880 CIMProperty tmp;
881
882 if (!getProperty(tmp))
883 mike 1.1 {
884 return false;
885 }
886
887 rep->_properties.append(tmp);
888 }
889 }
890
891 // Replace rep:
892 CIMInstanceRep*& tmp = *((CIMInstanceRep**)&x);
893
894 if (tmp)
895 tmp->Dec();
896
897 tmp = rep;
898
899 return true;
900 }
901
902 void CIMBuffer::putClass(const CIMClass& x)
903 {
904 mike 1.1 const CIMClassRep* rep = *((const CIMClassRep**)&x);
905
906 // CLASS_MAGIC:
907 _putMagic(CLASS_MAGIC);
908
909 // CIMClass.initialized:
910
911 if (x.isUninitialized())
912 {
913 putBoolean(false);
914 return;
915 }
916 else
917 putBoolean(true);
918
919 // CIMInstance.reference:
920 putObjectPath(rep->_reference);
921
922 // CIMClass.superClassName:
923 putString(rep->_superClassName.getString());
924
925 mike 1.1 // CIMClass.qualifiers:
926 putQualifierList(rep->_qualifiers);
927
928 // CIMClass.properties:
929 {
930 Uint32 n = rep->_properties.size();
931 putUint32(n);
932
933 for (Uint32 i = 0; i < n; i++)
934 putProperty(rep->_properties[i]);
935 }
936
937 // CIMClass.methods:
938 {
939 Uint32 n = rep->_methods.size();
940 putUint32(n);
941
942 for (Uint32 i = 0; i < n; i++)
943 putMethod(rep->_methods[i]);
944 }
945 }
946 mike 1.1
947 bool CIMBuffer::getClass(CIMClass& x)
948 {
949 CIMClassRep* rep;
950 String className;
951 String superClassName;
952
953 // CLASS_MAGIC:
954
955 if (!_testMagic(CLASS_MAGIC))
956 return false;
957
958 // initialized:
959
960 Boolean initialized;
961
962 if (!getBoolean(initialized))
963 return false;
964
965 if (!initialized)
966 {
967 mike 1.1 x = CIMClass();
968 return true;
969 }
970
971 // CIMIntsance.reference:
972
973 CIMObjectPath reference;
974
975 if (!getObjectPath(reference))
976 return false;
977
978 // CIMIntsance.superClassName:
979
980 if (!getString(superClassName))
981 return false;
982
983 rep = new CIMClassRep(reference.getClassName(),
984 _CIMNameCast(superClassName));
985
986 rep->_reference = reference;
987
988 mike 1.1 // CIMClass.qualifiers:
989
990 if (!getQualifierList(rep->_qualifiers))
991 return false;
992
993 // CIMClass.properties:
994 {
995 Uint32 n;
996
997 if (!getUint32(n))
998 return false;
999
1000 for (Uint32 i = 0; i < n; i++)
1001 {
1002 CIMProperty tmp;
1003
1004 if (!getProperty(tmp))
1005 return false;
1006
1007 rep->_properties.append(tmp);
1008 }
1009 mike 1.1 }
1010
1011 // CIMClass.methods:
1012 {
1013 Uint32 n;
1014
1015 if (!getUint32(n))
1016 return false;
1017
1018 for (Uint32 i = 0; i < n; i++)
1019 {
1020 CIMMethod tmp;
1021
1022 if (!getMethod(tmp))
1023 return false;
1024
1025 rep->_methods.append(tmp);
1026 }
1027 }
1028
1029 // Replace rep:
1030 mike 1.1 CIMClassRep*& tmp = *((CIMClassRep**)&x);
1031
1032 if (tmp)
1033 tmp->Dec();
1034
1035 tmp = rep;
1036
1037 return true;
1038 }
1039
1040 void CIMBuffer::putParameter(const CIMParameter& x)
1041 {
1042 const CIMParameterRep* rep = *((const CIMParameterRep**)&x);
1043
1044 // CIMParameter.name
1045 putString(rep->_name.getString());
1046
1047 // CIMParameter.type
1048 putUint32(rep->_type);
1049
1050 // CIMParameter.isArray
1051 mike 1.1 putBoolean(rep->_isArray);
1052
1053 // CIMParameter.arraySize
1054 putUint32(rep->_arraySize);
1055
1056 // CIMParameter.referenceClassName
1057 putString(rep->_referenceClassName.getString());
1058
1059 // CIMParameter.qualifiers
1060 putQualifierList(rep->_qualifiers);
1061 }
1062
1063 bool CIMBuffer::getParameter(CIMParameter& x)
1064 {
1065 String name;
1066 Uint32 type;
1067 Boolean isArray;
1068 Uint32 arraySize;
1069 String referenceClassName;
1070
1071 // CIMParameter.name
1072 mike 1.1 if (!getString(name))
1073 return false;
1074
1075 // CIMParameter.type
1076 if (!getUint32(type))
1077 return false;
1078
1079 // CIMParameter.isArray
1080 if (!getBoolean(isArray))
1081 return false;
1082
1083 // CIMParameter.arraySize
1084 if (!getUint32(arraySize))
1085 return false;
1086
1087 // CIMParameter.referenceClassName
1088 if (!getString(referenceClassName))
1089 return false;
1090
1091 x.~CIMParameter();
1092
1093 mike 1.1 new(&x) CIMParameter(
1094 _CIMNameCast(name),
1095 CIMType(type),
1096 isArray,
1097 arraySize,
1098 _CIMNameCast(referenceClassName));
1099
1100 CIMParameterRep* rep = *((CIMParameterRep**)&x);
1101
1102 // CIMParameter.qualifiers
1103 if (!getQualifierList(rep->_qualifiers))
1104 return false;
1105
1106 return true;
1107 }
1108
1109 void CIMBuffer::putMethod(const CIMMethod& x)
1110 {
1111 const CIMMethodRep* rep = *((const CIMMethodRep**)&x);
1112
1113 // CIMParameter.name
1114 mike 1.1 putString(rep->_name.getString());
1115
1116 // CIMParameter.type
1117 putUint32(rep->_type);
1118
1119 // CIMProperty.classOrigin
1120 putString(rep->_classOrigin.getString());
1121
1122 // CIMProperty.propagated
1123 putBoolean(rep->_propagated);
1124
1125 // CIMMethod.qualifiers:
1126 putQualifierList(rep->_qualifiers);
1127
1128 // CIMMethod.parameters:
1129 {
1130 Uint32 n = rep->_parameters.size();
1131 putUint32(n);
1132
1133 for (Uint32 i = 0; i < n; i++)
1134 putParameter(rep->_parameters[i]);
1135 mike 1.1 }
1136 }
1137
1138 bool CIMBuffer::getMethod(CIMMethod& x)
1139 {
1140 CIMMethodRep* rep;
1141
1142 String name;
1143 Uint32 type;
1144 String classOrigin;
1145 Boolean propagated;
1146
1147 // CIMMethod.name
1148 if (!getString(name))
1149 return false;
1150
1151 // CIMMethod.type
1152 if (!getUint32(type))
1153 return false;
1154
1155 // CIMParameter.classOrigin
1156 mike 1.1 if (!getString(classOrigin))
1157 return false;
1158
1159 // CIMParameter.propagated
1160 if (!getBoolean(propagated))
1161 return false;
1162
1163 rep = new CIMMethodRep(name, CIMType(type), classOrigin, propagated);
1164
1165 // CIMMethod.qualifiers:
1166 if (!getQualifierList(rep->_qualifiers))
1167 return false;
1168
1169 // CIMMethod.parameters:
1170 {
1171 Uint32 n;
1172
1173 if (!getUint32(n))
1174 return false;
1175
1176 for (Uint32 i = 0; i < n; i++)
1177 mike 1.1 {
1178 CIMParameter tmp;
1179
1180 if (!getParameter(tmp))
1181 return false;
1182
1183 rep->_parameters.append(tmp);
1184 }
1185 }
1186
1187 // Replace rep:
1188
1189 CIMMethodRep*& tmp = *((CIMMethodRep**)&x);
1190
1191 if (tmp)
1192 tmp->Dec();
1193
1194 tmp = rep;
1195
1196 return true;
1197 }
1198 mike 1.1
1199 void CIMBuffer::putPropertyList(const CIMPropertyList& x)
1200 {
1201 CIMPropertyListRep* rep = *((CIMPropertyListRep**)&x);
1202
1203 putBoolean(rep->isNull);
1204
1205 if (!rep->isNull)
1206 {
1207 Uint32 n = rep->propertyNames.size();
1208 putUint32(n);
1209
1210 for (Uint32 i = 0; i < n; i++)
1211 putString(rep->propertyNames[i].getString());
1212 }
1213 }
1214
1215 bool CIMBuffer::getPropertyList(CIMPropertyList& x)
1216 {
1217 Boolean isNull;
1218
1219 mike 1.1 if (!getBoolean(isNull))
1220 return false;
1221
1222 if (isNull)
1223 {
1224 x.~CIMPropertyList();
1225 new(&x) CIMPropertyList();
1226 }
1227 else
1228 {
1229 Array<CIMName> names;
1230
1231 Uint32 n;
1232
1233 if (!getUint32(n))
1234 return false;
1235
1236 for (Uint32 i = 0; i < n; i++)
1237 {
1238 String name;
1239
1240 mike 1.1 if (!getString(name))
1241 return false;
1242
1243 names.append(_CIMNameCast(name));
1244 }
1245
1246 x.~CIMPropertyList();
1247 new(&x) CIMPropertyList(names);
1248 }
1249
1250 return true;
1251 }
1252
1253 void CIMBuffer::putObject(const CIMObject& x)
1254 {
1255 _putMagic(OBJECT_MAGIC);
1256
1257 if (x.isUninitialized())
1258 {
1259 putBoolean(false);
1260 return;
1261 mike 1.1 }
1262 else
1263 putBoolean(true);
1264
1265 if (x.isInstance())
1266 {
1267 putUint8('I');
1268 putInstance(CIMInstance(x));
1269 }
1270 else
1271 {
1272 putUint8('C');
1273 putClass(CIMClass(x));
1274 }
1275 }
1276
1277 bool CIMBuffer::getObject(CIMObject& x)
1278 {
1279 Boolean initialized;
1280 Uint8 tag;
1281
1282 mike 1.1 if (!_testMagic(OBJECT_MAGIC))
1283 return false;
1284
1285 if (!getBoolean(initialized))
1286 return false;
1287
1288 if (!initialized)
1289 {
1290 x = CIMObject();
1291 return true;
1292 }
1293
1294 if (!getUint8(tag))
1295 return false;
1296
1297 if (tag == 'I')
1298 {
1299 CIMInstance tmp;
1300
1301 if (!getInstance(tmp))
1302 return false;
1303 mike 1.1
1304 x.~CIMObject();
1305 new(&x) CIMObject(tmp);
1306 return true;
1307 }
1308 else if (tag == 'C')
1309 {
1310 CIMClass tmp;
1311
1312 if (!getClass(tmp))
1313 return false;
1314
1315 x.~CIMObject();
1316 new(&x) CIMObject(tmp);
1317 return true;
1318 }
1319 else
1320 return false;
1321
1322 }
1323
1324 mike 1.1 void CIMBuffer::putParamValue(const CIMParamValue& x)
1325 {
1326 const CIMParamValueRep* rep = *((const CIMParamValueRep**)&x);
1327
1328 // CIMParamValue.parameterName:
1329 putString(rep->_parameterName);
1330
1331 // CIMParamValue.value:
1332 putValue(rep->_value);
1333
1334 // CIMParamValue.isTyped:
1335 putBoolean(rep->_isTyped);
1336 }
1337
1338 bool CIMBuffer::getParamValue(CIMParamValue& x)
1339 {
1340 String parameterName;
1341 CIMValue value;
1342 Boolean isTyped;
1343
1344 // CIMParamValue.parameterName:
1345 mike 1.1 if (!getString(parameterName))
1346 return false;
1347
1348 // CIMParamValue.value:
1349 if (!getValue(value))
1350 return false;
1351
1352 // CIMParamValue.isTyped:
1353 if (!getBoolean(isTyped))
1354 return false;
1355
1356 x.~CIMParamValue();
1357 new(&x) CIMParamValue(parameterName, value, isTyped);
1358
1359 return true;
1360 }
1361
1362 void CIMBuffer::putPresent(Boolean flag)
1363 {
1364 if (flag)
1365 putUint32(PRESENT_MAGIC);
1366 mike 1.1 else
1367 putUint32(ABSENT_MAGIC);
1368 }
1369
1370 bool CIMBuffer::getPresent(Boolean& flag)
1371 {
1372 Uint32 tmp;
1373
1374 if (!getUint32(tmp))
1375 return false;
1376
1377 if (tmp == PRESENT_MAGIC)
1378 {
1379 flag = true;
1380 return true;
1381 }
1382 else if (tmp == ABSENT_MAGIC)
1383 {
1384 flag = false;
1385 return true;
1386 }
1387 mike 1.1
1388 return false;
1389 }
1390
1391 PEGASUS_NAMESPACE_END
|
Return to
CIMBuffer.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common