1 martin 1.7 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.8 //
|
3 martin 1.7 // 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.8 //
|
10 martin 1.7 // 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.8 //
|
17 martin 1.7 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.8 //
|
20 martin 1.7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.8 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.7 // 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.8 //
|
28 martin 1.7 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.1 #ifndef Pegasus_CIMBuffer_h
30 #define Pegasus_CIMBuffer_h
31
32 #include <Pegasus/Common/Config.h>
33 #include <Pegasus/Common/CIMInstance.h>
34 #include <Pegasus/Common/CIMClass.h>
35 #include <Pegasus/Common/CIMQualifierList.h>
|
36 mike 1.5 #include <Pegasus/Common/CIMQualifierDecl.h>
|
37 mike 1.1 #include <Pegasus/Common/CIMParamValue.h>
|
38 mike 1.5 #include <Pegasus/Common/Buffer.h>
|
39 kumpf 1.4 #include <Pegasus/Common/CIMNameCast.h>
|
40 sahana.prabhakar 1.10 #include <Pegasus/Common/CIMDateTimeRep.h>
|
41 mike 1.1
42 #define PEGASUS_USE_MAGIC
43
44 PEGASUS_NAMESPACE_BEGIN
45
46 /** This class serializes/deserializes CIM objects (String, CIMInstance, etc.)
47 to/from a binary message stream. Serialized objects have two main
48 characteristics. (1) They are aligned on suitable boundaries so the basic
49 types can be accessed in place without the risk of aligment faults. (2)
50 They represents strings as UCS2 characters. Performance is an overriding
51 design goal of this class. The CIMBuffer class is suitable for binary
52 protocols since it sacrifices size for performance; Whereas the Packer
|
53 kumpf 1.9 class is more suitable for disk storage since it favors size over
|
54 mike 1.1 performance.
|
55 mike 1.5
56 CIMBuffer handles network byte ordering. It uses a "reader makes right"
57 policy whereby the writing process sends data in his own endianess,
58 which he comminicates to the reading process (using a mechanism defined
59 outside of this class). The reader checks to see if that endianess is
60 the same as his own. If so, the data is used as is. Otherwise, the
|
61 kumpf 1.9 reader calls CIMBuffer::setSwap(true) to cause subsequent get calls to
|
62 mike 1.5 swap data ordering.
|
63 mike 1.1 */
|
64 kumpf 1.2 class PEGASUS_COMMON_LINKAGE CIMBuffer
|
65 mike 1.1 {
66 public:
67
|
68 mike 1.5 CIMBuffer();
69
|
70 mike 1.1 CIMBuffer(size_t size);
71
72 CIMBuffer(char* data, size_t size)
73 {
74 _data = data;
75 _ptr = _data;
76 _end = data + size;
|
77 mike 1.5 _swap = 0;
78 _validate = 0;
|
79 mike 1.1 }
80
81 ~CIMBuffer();
82
|
83 mike 1.5 void setSwap(bool x)
84 {
85 _swap = x ? 1 : 0;
86 }
87
88 void setValidate(bool x)
89 {
90 _validate = x ? 1 : 0;
91 }
92
93 bool more() const
94 {
95 return _ptr != _end;
96 }
97
|
98 mike 1.1 void rewind()
99 {
100 _ptr = _data;
101 }
102
103 size_t capacity()
104 {
105 return _end - _data;
106 }
107
108 size_t size()
109 {
110 return _ptr - _data;
111 }
112
|
113 kumpf 1.9 const char* getData() const
|
114 mike 1.1 {
115 return _data;
116 }
117
|
118 kumpf 1.9 const char* getPtr() const
|
119 mike 1.5 {
120 return _ptr;
121 }
122
123 char* release()
124 {
125 char* data = _data;
126 _data = 0;
127 _ptr = 0;
128 _end = 0;
129 return data;
130 }
131
|
132 mike 1.1 static size_t round(size_t size)
133 {
134 /* Round up to nearest multiple of 8 */
135 return (size + 7) & ~7;
136 }
137
138 void putBoolean(Boolean x)
139 {
140 if (_end - _ptr < 8)
141 _grow(sizeof(x));
142
|
143 mike 1.5 *((Uint8*)_ptr) = x ? 1 : 0;
|
144 mike 1.1 _ptr += 8;
145 }
146
147 void putUint8(Uint8 x)
148 {
149 if (_end - _ptr < 8)
150 _grow(sizeof(x));
151
152 *((Uint8*)_ptr) = x;
153 _ptr += 8;
154 }
155
156 void putSint8(Sint8 x)
157 {
158 if (_end - _ptr < 8)
159 _grow(sizeof(x));
160
161 *((Sint8*)_ptr) = x;
162 _ptr += 8;
163 }
164
165 mike 1.1 void putUint16(Uint16 x)
166 {
167 if (_end - _ptr < 8)
168 _grow(sizeof(x));
169
170 *((Uint16*)_ptr) = x;
171 _ptr += 8;
172 }
173
174 void putSint16(Sint16 x)
175 {
176 if (_end - _ptr < 8)
177 _grow(sizeof(x));
178
179 *((Sint16*)_ptr) = x;
180 _ptr += 8;
181 }
182
183 void putUint32(Uint32 x)
184 {
185 if (_end - _ptr < 8)
186 mike 1.1 _grow(sizeof(x));
187
188 *((Uint32*)_ptr) = x;
189 _ptr += 8;
190 }
191
192 void putSint32(Sint32 x)
193 {
194 if (_end - _ptr < 8)
195 _grow(sizeof(x));
196
197 *((Sint32*)_ptr) = x;
198 _ptr += 8;
199 }
200
201 void putUint64(Uint64 x)
202 {
203 if (_end - _ptr < 8)
204 _grow(sizeof(x));
205
206 *((Uint64*)_ptr) = x;
207 mike 1.1 _ptr += 8;
208 }
209
210 void putSint64(Sint64 x)
211 {
212 if (_end - _ptr < 8)
213 _grow(sizeof(x));
214
215 *((Sint64*)_ptr) = x;
216 _ptr += 8;
217 }
218
219 void putReal32(Real32 x)
220 {
221 if (_end - _ptr < 8)
222 _grow(sizeof(x));
223
224 *((Real32*)_ptr) = x;
225 _ptr += 8;
226 }
227
228 mike 1.1 void putReal64(Real64 x)
229 {
230 if (_end - _ptr < 8)
231 _grow(sizeof(x));
232
233 *((Real64*)_ptr) = x;
234 _ptr += 8;
235 }
236
237 void putChar16(Char16 x)
238 {
239 if (_end - _ptr < 8)
240 _grow(sizeof(x));
241
242 *((Char16*)_ptr) = x;
243 _ptr += 8;
244 }
245
246 void putBytes(const void* data, size_t size)
247 {
248 size_t r = round(size);
249 mike 1.1
250 if (_end - _ptr < ptrdiff_t(r))
251 _grow(r);
252
253 memcpy(_ptr, data, size);
254 _ptr += r;
255 }
256
257 void putString(const String& x)
258 {
259 Uint32 n = x.size();
260 putUint32(n);
261 putBytes(x.getChar16Data(), n * sizeof(Char16));
262 }
263
264 void putDateTime(const CIMDateTime& x)
265 {
|
266 sahana.prabhakar 1.10 putUint64(x._rep->usec);
267 putUint32(x._rep->utcOffset);
268 putUint16(x._rep->sign);
269 putUint16(x._rep->numWildcards);
|
270 mike 1.1 }
271
272 void putBooleanA(const Array<Boolean>& x)
273 {
274 Uint32 n = x.size();
275 putUint32(n);
|
276 mike 1.5
277 size_t r = round(n);
278
279 if (_end - _ptr < ptrdiff_t(r))
280 _grow(r);
281
282 for (Uint32 i = 0; i < n; i++)
283 _ptr[i] = x[i] ? 1 : 0;
284
285 _ptr += r;
|
286 mike 1.1 }
287
288 void putUint8A(const Array<Uint8>& x)
289 {
290 Uint32 n = x.size();
291 putUint32(n);
292 putBytes(x.getData(), n * sizeof(Uint8));
293 }
294
295 void putSint8A(const Array<Sint8>& x)
296 {
297 Uint32 n = x.size();
298 putUint32(n);
299 putBytes(x.getData(), n * sizeof(Sint8));
300 }
301
302 void putUint16A(const Array<Uint16>& x)
303 {
304 Uint32 n = x.size();
305 putUint32(n);
306 putBytes(x.getData(), n * sizeof(Uint16));
307 mike 1.1 }
308
309 void putSint16A(const Array<Sint16>& x)
310 {
311 Uint32 n = x.size();
312 putUint32(n);
313 putBytes(x.getData(), n * sizeof(Sint16));
314 }
315
316 void putUint32A(const Array<Uint32>& x)
317 {
318 Uint32 n = x.size();
319 putUint32(n);
320 putBytes(x.getData(), n * sizeof(Uint32));
321 }
322
323 void putSint32A(const Array<Sint32>& x)
324 {
325 Uint32 n = x.size();
326 putUint32(n);
327 putBytes(x.getData(), n * sizeof(Sint32));
328 mike 1.1 }
329
330 void putUint64A(const Array<Uint64>& x)
331 {
332 Uint32 n = x.size();
333 putUint32(n);
334 putBytes(x.getData(), n * sizeof(Uint64));
335 }
336
337 void putSint64A(const Array<Sint64>& x)
338 {
339 Uint32 n = x.size();
340 putUint32(n);
341 putBytes(x.getData(), n * sizeof(Sint64));
342 }
343
344 void putReal32A(const Array<Real32>& x)
345 {
346 Uint32 n = x.size();
347 putUint32(n);
348 putBytes(x.getData(), n * sizeof(Real32));
349 mike 1.1 }
350
351 void putReal64A(const Array<Real64>& x)
352 {
353 Uint32 n = x.size();
354 putUint32(n);
355 putBytes(x.getData(), n * sizeof(Real64));
356 }
357
358 void putChar16A(const Array<Char16>& x)
359 {
360 Uint32 n = x.size();
361 putUint32(n);
362 putBytes(x.getData(), n * sizeof(Char16));
363 }
364
365 void putStringA(const Array<String>& x)
366 {
367 Uint32 n = x.size();
368 putUint32(n);
369
370 mike 1.1 for (size_t i = 0; i < n; i++)
371 putString(x[i]);
372 }
373
374 void putDateTimeA(const Array<CIMDateTime>& x)
375 {
376 Uint32 n = x.size();
377 putUint32(n);
378
379 for (size_t i = 0; i < n; i++)
380 putDateTime(x[i]);
381 }
382
|
383 mike 1.5 bool getBytes(void* data, size_t size)
384 {
385 size_t r = round(size);
386
387 if (_end - _ptr < ptrdiff_t(r))
388 return false;
389
390 memcpy(data, _ptr, size);
391 _ptr += r;
392 return true;
393 }
394
|
395 mike 1.1 bool getBoolean(Boolean& x)
396 {
397 if (_end - _ptr < 8)
398 return false;
399
|
400 mike 1.5 x = *((Uint8*)_ptr);
|
401 mike 1.1 _ptr += 8;
402 return true;
403 }
404
405 bool getUint8(Uint8& x)
406 {
407 if (_end - _ptr < 8)
408 return false;
409
410 x = *((Uint8*)_ptr);
411 _ptr += 8;
412 return true;
413 }
414
415 bool getSint8(Sint8& x)
416 {
417 if (_end - _ptr < 8)
418 return false;
419
420 x = *((Sint8*)_ptr);
421 _ptr += 8;
422 mike 1.1 return true;
423 }
424
425 bool getUint16(Uint16& x)
426 {
427 if (_end - _ptr < 8)
428 return false;
429
430 x = *((Uint16*)_ptr);
|
431 mike 1.5
432 if (_swap)
|
433 kumpf 1.9 x = _swapUint16(x);
|
434 mike 1.5
|
435 mike 1.1 _ptr += 8;
436 return true;
437 }
438
439 bool getSint16(Sint16& x)
440 {
441 if (_end - _ptr < 8)
442 return false;
443
444 x = *((Sint16*)_ptr);
|
445 mike 1.5
446 if (_swap)
|
447 kumpf 1.9 x = _swapSint16(x);
|
448 mike 1.5
|
449 mike 1.1 _ptr += 8;
450 return true;
451 }
452
453 bool getUint32(Uint32& x)
454 {
455 if (_end - _ptr < 8)
456 return false;
457
458 x = *((Uint32*)_ptr);
|
459 mike 1.5
460 if (_swap)
|
461 kumpf 1.9 x = _swapUint32(x);
|
462 mike 1.5
|
463 mike 1.1 _ptr += 8;
464 return true;
465 }
466
467 bool getSint32(Sint32& x)
468 {
469 if (_end - _ptr < 8)
470 return false;
471
472 x = *((Sint32*)_ptr);
|
473 mike 1.5
474 if (_swap)
|
475 kumpf 1.9 x = _swapSint32(x);
|
476 mike 1.5
|
477 mike 1.1 _ptr += 8;
478 return true;
479 }
480
481 bool getUint64(Uint64& x)
482 {
483 if (_end - _ptr < 8)
484 return false;
485
486 x = *((Uint64*)_ptr);
|
487 mike 1.5
488 if (_swap)
|
489 kumpf 1.9 x = _swapUint64(x);
|
490 mike 1.5
|
491 mike 1.1 _ptr += 8;
492 return true;
493 }
494
495 bool getSint64(Sint64& x)
496 {
497 if (_end - _ptr < 8)
498 return false;
499
500 x = *((Sint64*)_ptr);
|
501 mike 1.5
502 if (_swap)
|
503 kumpf 1.9 x = _swapSint64(x);
|
504 mike 1.5
|
505 mike 1.1 _ptr += 8;
506 return true;
507 }
508
509 bool getReal32(Real32& x)
510 {
511 if (_end - _ptr < 8)
512 return false;
513
514 x = *((Real32*)_ptr);
|
515 mike 1.5
516 if (_swap)
|
517 kumpf 1.9 x = _swapReal32(x);
|
518 mike 1.5
|
519 mike 1.1 _ptr += 8;
520 return true;
521 }
522
523 bool getReal64(Real64& x)
524 {
525 if (_end - _ptr < 8)
526 return false;
527
528 x = *((Real64*)_ptr);
|
529 mike 1.5
530 if (_swap)
|
531 kumpf 1.9 x = _swapReal64(x);
|
532 mike 1.5
|
533 mike 1.1 _ptr += 8;
534 return true;
535 }
536
537 bool getChar16(Char16& x)
538 {
539 if (_end - _ptr < 8)
540 return false;
541
542 x = *((Char16*)_ptr);
|
543 mike 1.5
544 if (_swap)
545 x = _swapChar16(x);
546
|
547 mike 1.1 _ptr += 8;
548 return true;
549 }
550
551 bool getString(String& x);
552
553 bool getDateTime(CIMDateTime& x)
554 {
555 Uint64 usec;
556
557 if (!getUint64(usec))
558 return false;
559
|
560 sahana.prabhakar 1.10 Uint32 utcOffset;
|
561 mike 1.1
|
562 sahana.prabhakar 1.10 if (!getUint32(utcOffset))
|
563 mike 1.1 return false;
564
|
565 sahana.prabhakar 1.10 Uint16 sign;
566
567 if (!getUint16(sign))
568 return false;
569
570 Uint16 numWildcards;
571
572 if (!getUint16(numWildcards))
573 return false;
574
575 CIMDateTimeRep *rep = new CIMDateTimeRep;
576 rep->usec = usec;
577 rep->utcOffset = utcOffset;
578 rep->sign = sign;
579 rep->numWildcards = numWildcards;
580 x = CIMDateTime(rep);
|
581 mike 1.1 return true;
582 }
583
584 bool getBooleanA(Array<Boolean>& x)
585 {
586 Uint32 n;
587
588 if (!getUint32(n))
589 return false;
590
|
591 mike 1.5 size_t r = round(n);
|
592 mike 1.1
593 if (_end - _ptr < ptrdiff_t(r))
594 return false;
595
|
596 mike 1.5 for (Uint32 i = 0; i < n; i++)
597 {
598 x.append(_ptr[i]);
599 }
600
|
601 mike 1.1 _ptr += r;
602 return true;
603 }
604
605 bool getUint8A(Array<Uint8>& x)
606 {
607 Uint32 n;
608
609 if (!getUint32(n))
610 return false;
611
612 size_t r = round(n * sizeof(Uint8));
613
614 if (_end - _ptr < ptrdiff_t(r))
615 return false;
616
617 x.append((const Uint8*)_ptr, n);
618 _ptr += r;
619 return true;
620 }
621
622 mike 1.1 bool getSint8A(Array<Sint8>& x)
623 {
624 Uint32 n;
625
626 if (!getUint32(n))
627 return false;
628
629 size_t r = round(n * sizeof(Sint8));
630
631 if (_end - _ptr < ptrdiff_t(r))
632 return false;
633
634 x.append((const Sint8*)_ptr, n);
635 _ptr += r;
636 return true;
637 }
638
639 bool getUint16A(Array<Uint16>& x)
640 {
641 Uint32 n;
642
643 mike 1.1 if (!getUint32(n))
644 return false;
645
646 size_t r = round(n * sizeof(Uint16));
647
648 if (_end - _ptr < ptrdiff_t(r))
649 return false;
650
651 x.append((const Uint16*)_ptr, n);
|
652 mike 1.5
653 if (_swap)
654 _swapUint16Data((Uint16*)x.getData(), x.size());
655
|
656 mike 1.1 _ptr += r;
657 return true;
658 }
659
660 bool getSint16A(Array<Sint16>& x)
661 {
662 Uint32 n;
663
664 if (!getUint32(n))
665 return false;
666
667 size_t r = round(n * sizeof(Sint16));
668
669 if (_end - _ptr < ptrdiff_t(r))
670 return false;
671
672 x.append((const Sint16*)_ptr, n);
|
673 mike 1.5
674 if (_swap)
675 _swapSint16Data((Sint16*)x.getData(), x.size());
676
|
677 mike 1.1 _ptr += r;
678 return true;
679 }
680
681 bool getUint32A(Array<Uint32>& x)
682 {
683 Uint32 n;
684
685 if (!getUint32(n))
686 return false;
687
688 size_t r = round(n * sizeof(Uint32));
689
690 if (_end - _ptr < ptrdiff_t(r))
691 return false;
692
693 x.append((const Uint32*)_ptr, n);
|
694 mike 1.5
695 if (_swap)
696 _swapUint32Data((Uint32*)x.getData(), x.size());
697
|
698 mike 1.1 _ptr += r;
699 return true;
700 }
701
702 bool getSint32A(Array<Sint32>& x)
703 {
704 Uint32 n;
705
706 if (!getUint32(n))
707 return false;
708
709 size_t r = round(n * sizeof(Sint32));
710
711 if (_end - _ptr < ptrdiff_t(r))
712 return false;
713
714 x.append((const Sint32*)_ptr, n);
|
715 mike 1.5
716 if (_swap)
717 _swapSint32Data((Sint32*)x.getData(), x.size());
718
|
719 mike 1.1 _ptr += r;
720 return true;
721 }
722
723 bool getUint64A(Array<Uint64>& x)
724 {
725 Uint32 n;
726
727 if (!getUint32(n))
728 return false;
729
730 size_t r = round(n * sizeof(Uint64));
731
732 if (_end - _ptr < ptrdiff_t(r))
733 return false;
734
735 x.append((const Uint64*)_ptr, n);
|
736 mike 1.5
737 if (_swap)
738 _swapUint64Data((Uint64*)x.getData(), x.size());
739
|
740 mike 1.1 _ptr += r;
741 return true;
742 }
743
744 bool getSint64A(Array<Sint64>& x)
745 {
746 Uint32 n;
747
748 if (!getUint32(n))
749 return false;
750
751 size_t r = round(n * sizeof(Sint64));
752
753 if (_end - _ptr < ptrdiff_t(r))
754 return false;
755
756 x.append((const Sint64*)_ptr, n);
|
757 mike 1.5
758 if (_swap)
759 _swapSint64Data((Sint64*)x.getData(), x.size());
760
|
761 mike 1.1 _ptr += r;
762 return true;
763 }
764
765 bool getReal32A(Array<Real32>& x)
766 {
767 Uint32 n;
768
769 if (!getUint32(n))
770 return false;
771
772 size_t r = round(n * sizeof(Real32));
773
774 if (_end - _ptr < ptrdiff_t(r))
775 return false;
776
777 x.append((const Real32*)_ptr, n);
|
778 mike 1.5
779 if (_swap)
780 _swapReal32Data((Real32*)x.getData(), x.size());
781
|
782 mike 1.1 _ptr += r;
783 return true;
784 }
785
786 bool getReal64A(Array<Real64>& x)
787 {
788 Uint32 n;
789
790 if (!getUint32(n))
791 return false;
792
793 size_t r = round(n * sizeof(Real64));
794
795 if (_end - _ptr < ptrdiff_t(r))
796 return false;
797
798 x.append((const Real64*)_ptr, n);
|
799 mike 1.5
800 if (_swap)
801 _swapReal64Data((Real64*)x.getData(), x.size());
802
|
803 mike 1.1 _ptr += r;
804 return true;
805 }
806
807 bool getChar16A(Array<Char16>& x)
808 {
809 Uint32 n;
810
811 if (!getUint32(n))
812 return false;
813
814 size_t r = round(n * sizeof(Char16));
815
816 if (_end - _ptr < ptrdiff_t(r))
817 return false;
818
819 x.append((const Char16*)_ptr, n);
|
820 mike 1.5
821 if (_swap)
822 _swapChar16Data((Char16*)x.getData(), x.size());
823
|
824 mike 1.1 _ptr += r;
825 return true;
826 }
827
|
828 r.kieninger 1.11 // ATTENTION:
829 // This method returns a reference to the data in the buffer rather
830 // than a new copy. The data will only be valid through the lifetime
831 // of the CIMBuffer.
832 bool getFastChar16Array(Char16** x, Uint32& n)
833 {
834 if (!getUint32(n))
835 return false;
836
837 size_t r = round(n * sizeof(Char16));
838
839 if (_end - _ptr < ptrdiff_t(r))
840 return false;
841
842 *x = (Char16*)_ptr;
843
844 if (_swap)
845 _swapChar16Data(*x, n);
846
847 _ptr += r;
848 return true;
849 r.kieninger 1.11 }
850
|
851 mike 1.1 bool getStringA(Array<String>& x)
852 {
853 Uint32 n;
854
855 if (!getUint32(n))
856 return false;
857
858 for (Uint32 i = 0; i < n; i++)
859 {
860 String tmp;
861
862 if (!getString(tmp))
863 return false;
864
865 x.append(tmp);
866 }
867
868 return true;
869 }
870
871 bool getDateTimeA(Array<CIMDateTime>& x)
872 mike 1.1 {
873 Uint32 n;
874
875 if (!getUint32(n))
876 return false;
877
878 for (Uint32 i = 0; i < n; i++)
879 {
880 CIMDateTime tmp;
881
882 if (!getDateTime(tmp))
883 return false;
884
885 x.append(tmp);
886 }
887
888 return true;
889 }
890
891 void putValue(const CIMValue& x);
892
893 mike 1.1 bool getValue(CIMValue& x);
894
895 void putKeyBinding(const CIMKeyBinding& x);
896
897 bool getKeyBinding(CIMKeyBinding& x);
898
|
899 mike 1.5 // To omit the host and namespace elements of the object path, set
900 // includeHostAndNamespace to false. This is required for compatibility with
901 // XML transmission of instances, which excludes these elements.
902 void putObjectPath(
|
903 kumpf 1.9 const CIMObjectPath& x,
|
904 mike 1.5 bool includeHostAndNamespace = true,
905 bool includeKeyBindings = true);
|
906 mike 1.1
907 bool getObjectPath(CIMObjectPath& x);
908
909 void putQualifier(const CIMQualifier& x);
910
911 bool getQualifier(CIMQualifier& x);
912
913 void putQualifierList(const CIMQualifierList& x);
914
915 bool getQualifierList(CIMQualifierList& x);
916
|
917 mike 1.5 void putQualifierDecl(const CIMQualifierDecl& x);
918
919 bool getQualifierDecl(CIMQualifierDecl& x);
920
|
921 mike 1.1 void putProperty(const CIMProperty& x);
922
923 bool getProperty(CIMProperty& x);
924
|
925 mike 1.5 void putInstance(
|
926 kumpf 1.9 const CIMInstance& x,
|
927 mike 1.5 bool includeHostAndNamespace = true,
928 bool includeKeyBindings = true);
|
929 mike 1.1
930 bool getInstance(CIMInstance& x);
931
932 void putClass(const CIMClass& x);
933
934 bool getClass(CIMClass& x);
935
936 void putParameter(const CIMParameter& x);
937
938 bool getParameter(CIMParameter& x);
939
940 void putMethod(const CIMMethod& x);
941
942 bool getMethod(CIMMethod& x);
943
944 void putPropertyList(const CIMPropertyList& x);
945
946 bool getPropertyList(CIMPropertyList& x);
947
|
948 mike 1.5 void putObject(const CIMObject& x,
949 bool includeHostAndNamespace = true,
950 bool includeKeyBindings = true);
|
951 mike 1.1
952 bool getObject(CIMObject& x);
953
954 void putParamValue(const CIMParamValue& x);
955
956 bool getParamValue(CIMParamValue& x);
957
958 void putName(const CIMName& x)
959 {
960 putString(x.getString());
961 }
962
963 void putNamespaceName(const CIMNamespaceName& x)
964 {
965 putString(x.getString());
966 }
967
|
968 mike 1.5 bool getName(CIMName& x);
|
969 mike 1.1
|
970 mike 1.5 bool getNamespaceName(CIMNamespaceName& x);
|
971 mike 1.1
972 void putNameA(const Array<CIMName>& x)
973 {
974 Uint32 n = x.size();
975 putUint32(n);
976
977 for (size_t i = 0; i < n; i++)
978 putName(x[i]);
979 }
980
981 bool getNameA(Array<CIMName>& x)
982 {
983 Uint32 n;
984
985 if (!getUint32(n))
986 return false;
987
988 for (Uint32 i = 0; i < n; i++)
989 {
990 String tmp;
991
992 mike 1.1 if (!getString(tmp))
993 return false;
994
|
995 kumpf 1.3 x.append(CIMNameCast(tmp));
|
996 mike 1.1 }
997
998 return true;
999 }
1000
|
1001 mike 1.5 void putObjectPathA(
|
1002 kumpf 1.9 const Array<CIMObjectPath>& x,
|
1003 mike 1.5 bool includeHostAndNamespace = true)
|
1004 mike 1.1 {
1005 Uint32 n = x.size();
1006 putUint32(n);
1007
1008 for (size_t i = 0; i < n; i++)
|
1009 mike 1.5 putObjectPath(x[i], includeHostAndNamespace);
|
1010 mike 1.1 }
1011
1012 bool getObjectPathA(Array<CIMObjectPath>& x)
1013 {
1014 Uint32 n;
1015
1016 if (!getUint32(n))
1017 return false;
1018
1019 for (Uint32 i = 0; i < n; i++)
1020 {
1021 CIMObjectPath tmp;
1022
1023 if (!getObjectPath(tmp))
1024 return false;
1025
1026 x.append(tmp);
1027 }
1028
1029 return true;
1030 }
1031 mike 1.1
|
1032 mike 1.5 void putInstanceA(
|
1033 kumpf 1.9 const Array<CIMInstance>& x,
|
1034 mike 1.5 bool includeHostAndNamespace = true,
1035 bool includeKeyBindings = true);
1036
1037 bool getInstanceA(Array<CIMInstance>& x)
1038 {
1039 Uint32 n;
1040
1041 if (!getUint32(n))
1042 return false;
1043
1044 for (Uint32 i = 0; i < n; i++)
1045 {
1046 CIMInstance tmp;
1047
1048 if (!getInstance(tmp))
1049 return false;
1050
1051 x.append(tmp);
1052 }
1053
1054 return true;
1055 mike 1.5 }
1056
1057 void putClassA(const Array<CIMClass>& x)
|
1058 mike 1.1 {
1059 Uint32 n = x.size();
1060 putUint32(n);
1061
1062 for (size_t i = 0; i < n; i++)
|
1063 mike 1.5 putClass(x[i]);
|
1064 mike 1.1 }
1065
|
1066 mike 1.5 bool getClassA(Array<CIMClass>& x)
|
1067 mike 1.1 {
1068 Uint32 n;
1069
1070 if (!getUint32(n))
1071 return false;
1072
1073 for (Uint32 i = 0; i < n; i++)
1074 {
|
1075 mike 1.5 CIMClass tmp;
|
1076 mike 1.1
|
1077 mike 1.5 if (!getClass(tmp))
|
1078 mike 1.1 return false;
1079
1080 x.append(tmp);
1081 }
1082
1083 return true;
1084 }
1085
|
1086 mike 1.5 void putObjectA(
1087 const Array<CIMObject>& x,
1088 bool includeHostAndNamespace = true,
1089 bool includeKeyBindings = true)
|
1090 mike 1.1 {
1091 Uint32 n = x.size();
1092 putUint32(n);
1093
1094 for (size_t i = 0; i < n; i++)
|
1095 mike 1.5 putObject(x[i], includeHostAndNamespace, includeKeyBindings);
|
1096 mike 1.1 }
1097
1098 bool getObjectA(Array<CIMObject>& x)
1099 {
1100 Uint32 n;
1101
1102 if (!getUint32(n))
1103 return false;
1104
1105 for (Uint32 i = 0; i < n; i++)
1106 {
1107 CIMObject tmp;
1108
1109 if (!getObject(tmp))
1110 return false;
1111
1112 x.append(tmp);
1113 }
1114
1115 return true;
1116 }
1117 mike 1.1
1118 void putParamValueA(const Array<CIMParamValue>& x)
1119 {
1120 Uint32 n = x.size();
1121 putUint32(n);
1122
1123 for (size_t i = 0; i < n; i++)
1124 putParamValue(x[i]);
1125 }
1126
1127 bool getParamValueA(Array<CIMParamValue>& x)
1128 {
1129 Uint32 n;
1130
1131 if (!getUint32(n))
1132 return false;
1133
1134 for (Uint32 i = 0; i < n; i++)
1135 {
1136 CIMParamValue tmp;
1137
1138 mike 1.1 if (!getParamValue(tmp))
1139 return false;
1140
1141 x.append(tmp);
1142 }
1143
1144 return true;
1145 }
1146
|
1147 mike 1.5 void putQualifierDeclA(const Array<CIMQualifierDecl>& x)
1148 {
1149 Uint32 n = x.size();
1150 putUint32(n);
1151
1152 for (size_t i = 0; i < n; i++)
1153 putQualifierDecl(x[i]);
1154 }
1155
1156 bool getQualifierDeclA(Array<CIMQualifierDecl>& x)
1157 {
1158 Uint32 n;
1159
1160 if (!getUint32(n))
1161 return false;
1162
1163 for (Uint32 i = 0; i < n; i++)
1164 {
1165 CIMQualifierDecl tmp;
1166
1167 if (!getQualifierDecl(tmp))
1168 mike 1.5 return false;
1169
1170 x.append(tmp);
1171 }
1172
1173 return true;
1174 }
1175
|
1176 mike 1.1 void putPresent(Boolean flag);
1177
1178 bool getPresent(Boolean& flag);
1179
1180 private:
1181
|
1182 mike 1.5 void _create(size_t);
1183
|
1184 mike 1.1 void _grow(size_t size);
1185
1186 void _putMagic(Uint32 magic)
1187 {
1188 #if defined(PEGASUS_USE_MAGIC)
1189 putUint32(magic);
1190 #endif
1191 }
1192
1193 bool _testMagic(Uint32 magic)
1194 {
1195 #if defined(PEGASUS_USE_MAGIC)
1196 Uint32 tmp;
1197
1198 if (!getUint32(tmp))
1199 return false;
1200
1201 return tmp == magic;
1202 #else
1203 return true;
1204 #endif
1205 mike 1.1 }
1206
|
1207 mike 1.5 Uint16 _swapUint16(Uint16 x)
1208 {
1209 return (Uint16)(
1210 (((Uint16)(x) & 0x00ffU) << 8) |
1211 (((Uint16)(x) & 0xff00U) >> 8));
1212 }
1213
1214 Sint16 _swapSint16(Sint16 x)
1215 {
1216 return Sint16(_swapUint16(Uint16(x)));
1217 }
1218
1219 Char16 _swapChar16(Char16 x)
1220 {
1221 return Char16(_swapUint16(Uint16(x)));
1222 }
1223
1224 Uint32 _swapUint32(Uint32 x)
1225 {
1226 return (Uint32)(
1227 (((Uint32)(x) & 0x000000ffUL) << 24) |
1228 mike 1.5 (((Uint32)(x) & 0x0000ff00UL) << 8) |
1229 (((Uint32)(x) & 0x00ff0000UL) >> 8) |
1230 (((Uint32)(x) & 0xff000000UL) >> 24));
1231 }
1232
1233 Sint32 _swapSint32(Sint32 x)
1234 {
1235 return Sint32(_swapUint32(Uint32(x)));
1236 }
1237
1238 void _swapBytes(Uint8& x, Uint8& y)
1239 {
1240 Uint8 t = x;
1241 x = y;
1242 y = t;
1243 }
1244
1245 Uint64 _swapUint64(Uint64 x)
1246 {
1247 union
1248 {
1249 mike 1.5 Uint64 x;
1250 Uint8 bytes[8];
1251 }
1252 u;
1253
1254 u.x = x;
1255 _swapBytes(u.bytes[0], u.bytes[7]);
1256 _swapBytes(u.bytes[1], u.bytes[6]);
1257 _swapBytes(u.bytes[2], u.bytes[5]);
1258 _swapBytes(u.bytes[3], u.bytes[4]);
1259 return u.x;
1260 }
1261
1262 Sint64 _swapSint64(Sint64 x)
1263 {
1264 return Sint64(_swapUint64(Uint64(x)));
1265 }
1266
1267 Real32 _swapReal32(Real32 x)
1268 {
1269 return _swapUint32(*((Uint32*)(void*)&x));
1270 mike 1.5 }
1271
1272 Real64 _swapReal64(Real64 x)
1273 {
|
1274 marek 1.6 return _swapSint64(*((Sint64*)(void*)&x));
|
1275 mike 1.5 }
1276
1277 void _swapUint16Data(Uint16* p, Uint32 n)
1278 {
1279 for (; n--; p++)
1280 *p = _swapUint16(*p);
1281 }
1282
1283 void _swapSint16Data(Sint16* p, Uint32 n)
1284 {
1285 for (; n--; p++)
1286 *p = _swapSint16(*p);
1287 }
1288
1289 void _swapUint32Data(Uint32* p, Uint32 n)
1290 {
1291 for (; n--; p++)
1292 *p = _swapUint32(*p);
1293 }
1294
1295 void _swapSint32Data(Sint32* p, Uint32 n)
1296 mike 1.5 {
1297 for (; n--; p++)
1298 *p = _swapSint32(*p);
1299 }
1300
1301 void _swapUint64Data(Uint64* p, Uint32 n)
1302 {
1303 for (; n--; p++)
1304 *p = _swapUint64(*p);
1305 }
1306
1307 void _swapSint64Data(Sint64* p, Uint32 n)
1308 {
1309 for (; n--; p++)
1310 *p = _swapSint64(*p);
1311 }
1312
1313 void _swapReal32Data(Real32* p, Uint32 n)
1314 {
1315 for (; n--; p++)
1316 *p = _swapReal32(*p);
1317 mike 1.5 }
1318
1319 void _swapReal64Data(Real64* p, Uint32 n)
1320 {
1321 for (; n--; p++)
1322 *p = _swapReal64(*p);
1323 }
1324
1325 void _swapChar16Data(Char16* p, Uint32 n)
1326 {
1327 for (; n--; p++)
1328 *p = _swapChar16(*p);
1329 }
1330
|
1331 mike 1.1 char* _data;
1332 char* _end;
1333 char* _ptr;
|
1334 mike 1.5 // If non-zero, the endianess of reads is swapped (big-endian is changed
1335 // to little-endian and visa versa).
1336
1337 int _swap;
1338 int _validate;
|
1339 mike 1.1 };
1340
|
1341 r.kieninger 1.11
1342 struct CIMBufferReleaser
1343 {
1344 CIMBufferReleaser(CIMBuffer& buf) : _buf(buf)
1345 {
1346 }
1347
1348 ~CIMBufferReleaser()
1349 {
1350 _buf.release();
1351 }
1352
1353 private:
1354 CIMBuffer& _buf;
1355 };
1356
1357
1358
|
1359 mike 1.1 PEGASUS_NAMESPACE_END
1360
1361 #endif /* Pegasus_CIMBuffer_h */
|
Return to
CIMBuffer.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common