1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #include "dinstance.h"
26 #include <cctype>
27 #include <base/instance.h>
28 #include <base/strings.h>
29 #include <base/naming.h>
30 #include <base/schemadecl.h>
31 #include <base/helpers.h>
32
33 // ATTN: work on object size reduction of this module.
34
35 #define T MI_T
36
37 MI_BEGIN_NAMESPACE
38
39 static MI_Uint32 _FindPropertyDecl(
40 const MI_ClassDecl* cd,
41 const MI_Char* name)
42 {
43 mike 1.1 MI_PropertyDecl** start = cd->properties;
44 MI_PropertyDecl** end = start + cd->numProperties;
45 MI_PropertyDecl** p = start;
46 MI_Uint32 code;
47
48 code = Hash(name);
49
50 while (p != end)
51 {
52 if ((*p)->code == code && Zcasecmp((*p)->name, name) == 0)
53 return (MI_Uint32)(p - start);
54 p++;
55 }
56
57 return (MI_Uint32)-1;
58 }
59
60 void DInstance::COW()
61 {
62 DEBUG_ASSERT(m_self);
63 InstanceHeader* h = ((InstanceHeader*)m_self) - 1;
64 mike 1.1
65 if (h->u.refs != 1)
66 {
67 MI_Instance* self = m_self;
68 MI_Result r = MI_Instance_Clone(self, &m_self);
69 DEBUG_ASSERT(r == MI_RESULT_OK);
70 __MI_Instance_Unref(self);
71 MI_UNUSED(r);
72 }
73 }
74
75 DInstance::DInstance(const String& className, DInstance::MetaType metaType)
76 {
77 MI_Uint32 mt = 0;
78
79 switch (metaType)
80 {
81 case CLASS:
82 mt = MI_FLAG_CLASS;
83 break;
84 case ASSOCIATION:
85 mike 1.1 mt = MI_FLAG_ASSOCIATION;
86 break;
87 case INDICATION:
88 mt = MI_FLAG_INDICATION;
89 break;
90 case METHOD:
91 mt = MI_FLAG_METHOD;
92 break;
93 }
94
95 MI_Result r = Instance_NewDynamic(&m_self, className.Str(), mt, 0);
96 DEBUG_ASSERT(r == MI_RESULT_OK);
97 MI_UNUSED(r);
98 }
99
100 DInstance::DInstance()
101 {
102 MI_Result r = Instance_NewDynamic(&m_self, MI_T("DInstance"),
103 MI_FLAG_CLASS, 0);
104 DEBUG_ASSERT(r == MI_RESULT_OK);
105 MI_UNUSED(r);
106 mike 1.1 }
107
108 DInstance::DInstance(const DInstance& a)
109 {
110 __MI_Instance_Ref(m_self = a.m_self);
111 }
112
113 DInstance::~DInstance()
114 {
115 if (m_self)
116 __MI_Instance_Unref(m_self);
117 }
118
119 DInstance& DInstance::operator=(const DInstance& a)
120 {
121 if (m_self != a.m_self)
122 {
123 __MI_Instance_Unref(m_self);
124 __MI_Instance_Ref(m_self = a.m_self);
125 }
126
127 mike 1.1 return *this;
128 }
129
130 void DInstance::Swap(DInstance& a)
131 {
132 MI_Instance* tmp = m_self;
133 m_self = a.m_self;
134 a.m_self = tmp;
135 }
136
137 const MI_ClassDecl* DInstance::GetClassDecl() const
138 {
139 return m_self->classDecl;
140 }
141
142 #if defined(GetClassName)
143 # undef GetClassName
144 #endif
145
146 String DInstance::GetClassName() const
147 {
148 mike 1.1 return String(m_self->classDecl->name);
149 }
150
151 void DInstance::SetClassName(const String& className)
152 {
153 COW();
154 MI_Result r = Instance_SetClassName(m_self, className.Str());
155 DEBUG_ASSERT(r == MI_RESULT_OK);
156 MI_UNUSED(r);
157 }
158
159 String DInstance::GetNamespace() const
160 {
161 const MI_Char* nameSpace;
162 MI_Result r = MI_Instance_GetNameSpace(m_self, &nameSpace);
163 DEBUG_ASSERT(r == MI_RESULT_OK);
164 MI_UNUSED(r);
165
166 return String(nameSpace);
167 }
168
169 mike 1.1 void DInstance::SetNamespace(const String& nameSpace)
170 {
171 COW();
172 MI_Result r = MI_Instance_SetNameSpace(m_self, nameSpace.Str());
173 DEBUG_ASSERT(r == MI_RESULT_OK);
174 MI_UNUSED(r);
175 }
176
177 Uint32 DInstance::Count() const
178 {
179 return m_self->classDecl->numProperties;
180 }
181
182 Uint32 DInstance::Find(const String& name) const
183 {
184 Uint32 i;
185 Uint32 count = Count();
186
187 for (i = 0; i < count; i++)
188 {
189 const MI_Char* tmpName;
190 mike 1.1 MI_Result r;
191 r = MI_Instance_GetElementAt(m_self, i, &tmpName, NULL, NULL, NULL);
192
193 if (r != MI_RESULT_OK)
194 return (Uint32)-1;
195
196 if (name == tmpName)
197 return i;
198 }
199
200 return (Uint32)-1;
201 }
202
203 bool DInstance::GetType(Uint32 index, Type& type) const
204 {
205 MI_Result r;
206 r = MI_Instance_GetElementAt(m_self, index, NULL, NULL, &type, NULL);
207 return r == MI_RESULT_OK ? true : false;
208 }
209
210 bool DInstance::GetName(Uint32 index, String& name) const
211 mike 1.1 {
212 MI_Result r;
213 const MI_Char* tmpName;
214 r = MI_Instance_GetElementAt(m_self, index, &tmpName, NULL, NULL, NULL);
215 if (r != MI_RESULT_OK)
216 return false;
217
218 name = String(tmpName);
219 return true;
220 }
221
222 bool DInstance::GetFlags(Uint32 index, Uint32& flags) const
223 {
224 MI_Result r;
225 r = MI_Instance_GetElementAt(m_self, index, NULL, NULL, NULL, &flags);
226 return r == MI_RESULT_OK ? true : false;
227 }
228
229 bool DInstance::Clear(const String& name)
230 {
231 COW();
232 mike 1.1 MI_Result r;
233 r = MI_Instance_ClearElement(m_self, name.Str());
234 return (r == MI_RESULT_OK) ? true : false;
235 }
236
237 void DInstance::Print(
238 FILE* os,
239 MI_Uint32 level,
240 bool showNulls) const
241 {
242 MI_Result r = Instance_Print(m_self, os, level,
243 showNulls ? MI_TRUE : MI_FALSE);
244 DEBUG_ASSERT(r == MI_RESULT_OK);
245 MI_UNUSED(r);
246 }
247
248 DInstance::DInstance(MI_Instance* self, DInstance::AdoptTag) : m_self(self)
249 {
250 DEBUG_ASSERT(m_self != 0);
251 }
252
253 mike 1.1 DInstance::DInstance(MI_Instance* self, DInstance::CloneTag)
254 {
255 MI_Result r = MI_Instance_Clone(self, &m_self);
256 DEBUG_ASSERT(r == MI_RESULT_OK);
257 MI_UNUSED(r);
258 }
259
260 bool DInstance::AddValue(
261 const String& name,
262 const MI_Value* value,
263 Type type,
264 bool null,
265 bool key)
266 {
267 COW();
268 MI_Result r;
269 MI_Uint32 flags = 0;
270
271 if (key)
272 flags |= MI_FLAG_KEY;
273
274 mike 1.1 if (!value || null)
275 flags |= MI_FLAG_NULL;
276
277 r = MI_Instance_AddElement(m_self, name.Str(), value, type, flags);
278 return r == MI_RESULT_OK ? true : false;
279 }
280
281 bool DInstance::SetValue(
282 const String& name,
283 const MI_Value* value,
284 Type type,
285 bool null)
286 {
287 COW();
288 MI_Result r;
289 MI_Uint32 flags = 0;
290
291 if (!value || null)
292 flags |= MI_FLAG_NULL;
293
294 r = MI_Instance_SetElement(m_self, name.Str(), value, type, flags);
295 mike 1.1 return r == MI_RESULT_OK ? true : false;
296 }
297
298 bool DInstance::GetValue(
299 const String& name,
300 MI_Value* value,
301 Type& type,
302 bool& null,
303 bool& key) const
304 {
305 if (!value)
306 return false;
307
308 MI_Uint32 f;
309 MI_Result r;
310
311 r = MI_Instance_GetElement(m_self, name.Str(), value, &type, &f, 0);
312
313 if (r != MI_RESULT_OK)
314 return false;
315
316 mike 1.1 key = (f & MI_FLAG_KEY) ? true : false;
317 null = (f & MI_FLAG_NULL) ? true : false;
318
319 return true;
320 }
321
322 bool DInstance::GetValueAsType(
323 const String& name,
324 MI_Value* value,
325 Type expectedType,
326 bool& null,
327 bool& key) const
328 {
329 MI_Type type;
330
331 if (GetValue(name, value, type, null, key) != MI_RESULT_OK)
332 return false;
333
334 return type == expectedType;
335 }
336
337 mike 1.1 bool DInstance::GetBoolean(
338 const String& name,
339 Boolean& a,
340 bool& null,
341 bool& key) const
342 {
343 MI_Value v;
344
345 if (GetValueAsType(name, &v, MI_BOOLEAN, null, key) == MI_RESULT_OK)
346 {
347 a = Boolean(v.boolean);
348 return true;
349 }
350 return false;
351 }
352
353 bool DInstance::GetBooleanA(
354 const String& name,
355 BooleanA& a,
356 bool& null,
357 bool& key) const
358 mike 1.1 {
359 MI_Value v;
360
361 if (GetValueAsType(name, &v, MI_BOOLEANA, null, key) == MI_RESULT_OK)
362 {
363 a = BooleanA((Boolean*)v.booleana.data, v.booleana.size);
364 return true;
365 }
366 return false;
367 }
368
369 bool DInstance::GetUint8(
370 const String& name,
371 Uint8& a,
372 bool& null,
373 bool& key) const
374 {
375 MI_Value v;
376
377 if (GetValueAsType(name, &v, MI_UINT8, null, key) == MI_RESULT_OK)
378 {
379 mike 1.1 a = Uint8(v.uint8);
380 return true;
381 }
382 return false;
383 }
384
385 bool DInstance::GetUint8A(
386 const String& name,
387 Uint8A& a,
388 bool& null,
389 bool& key) const
390 {
391 MI_Value v;
392
393 if (GetValueAsType(name, &v, MI_UINT8A, null, key) == MI_RESULT_OK)
394 {
395 a = Uint8A((Uint8*)v.uint8a.data, v.uint8a.size);
396 return true;
397 }
398 return false;
399 }
400 mike 1.1
401 bool DInstance::GetSint8(
402 const String& name,
403 Sint8& a,
404 bool& null,
405 bool& key) const
406 {
407 MI_Value v;
408
409 if (GetValueAsType(name, &v, MI_SINT8, null, key) == MI_RESULT_OK)
410 {
411 a = Sint8(v.sint8);
412 return true;
413 }
414 return false;
415 }
416
417 bool DInstance::GetSint8A(
418 const String& name,
419 Sint8A& a,
420 bool& null,
421 mike 1.1 bool& key) const
422 {
423 MI_Value v;
424
425 if (GetValueAsType(name, &v, MI_SINT8A, null, key) == MI_RESULT_OK)
426 {
427 a = Sint8A((Sint8*)v.sint8a.data, v.sint8a.size);
428 return true;
429 }
430 return false;
431 }
432
433 bool DInstance::GetUint16(
434 const String& name,
435 Uint16& a,
436 bool& null,
437 bool& key) const
438 {
439 MI_Value v;
440
441 if (GetValueAsType(name, &v, MI_UINT16, null, key) == MI_RESULT_OK)
442 mike 1.1 {
443 a = Uint16(v.uint16);
444 return true;
445 }
446 return false;
447 }
448
449 bool DInstance::GetUint16A(
450 const String& name,
451 Uint16A& a,
452 bool& null,
453 bool& key) const
454 {
455 MI_Value v;
456
457 if (GetValueAsType(name, &v, MI_UINT16A, null, key) == MI_RESULT_OK)
458 {
459 a = Uint16A((Uint16*)v.uint16a.data, v.uint16a.size);
460 return true;
461 }
462 return false;
463 mike 1.1 }
464
465 bool DInstance::GetSint16(
466 const String& name,
467 Sint16& a,
468 bool& null,
469 bool& key) const
470 {
471 MI_Value v;
472
473 if (GetValueAsType(name, &v, MI_SINT16, null, key) == MI_RESULT_OK)
474 {
475 a = Sint16(v.sint16);
476 return true;
477 }
478 return false;
479 }
480
481 bool DInstance::GetSint16A(
482 const String& name,
483 Sint16A& a,
484 mike 1.1 bool& null,
485 bool& key) const
486 {
487 MI_Value v;
488
489 if (GetValueAsType(name, &v, MI_SINT16A, null, key) == MI_RESULT_OK)
490 {
491 a = Sint16A((Sint16*)v.sint16a.data, v.sint16a.size);
492 return true;
493 }
494 return false;
495 }
496
497 bool DInstance::GetUint32(
498 const String& name,
499 Uint32& a,
500 bool& null,
501 bool& key) const
502 {
503 MI_Value v;
504
505 mike 1.1 if (GetValueAsType(name, &v, MI_UINT32, null, key) == MI_RESULT_OK)
506 {
507 a = Uint32(v.uint32);
508 return true;
509 }
510 return false;
511 }
512
513 bool DInstance::GetUint32A(
514 const String& name,
515 Uint32A& a,
516 bool& null,
517 bool& key) const
518 {
519 MI_Value v;
520
521 if (GetValueAsType(name, &v, MI_UINT32A, null, key) == MI_RESULT_OK)
522 {
523 a = Uint32A((Uint32*)v.uint32a.data, v.uint32a.size);
524 return true;
525 }
526 mike 1.1 return false;
527 }
528
529 bool DInstance::GetSint32(
530 const String& name,
531 Sint32& a,
532 bool& null,
533 bool& key) const
534 {
535 MI_Value v;
536
537 if (GetValueAsType(name, &v, MI_SINT32, null, key) == MI_RESULT_OK)
538 {
539 a = Sint32(v.sint32);
540 return true;
541 }
542 return false;
543 }
544
545 bool DInstance::GetSint32A(
546 const String& name,
547 mike 1.1 Sint32A& a,
548 bool& null,
549 bool& key) const
550 {
551 MI_Value v;
552
553 if (GetValueAsType(name, &v, MI_SINT32A, null, key) == MI_RESULT_OK)
554 {
555 a = Sint32A((Sint32*)v.sint32a.data, v.sint32a.size);
556 return true;
557 }
558 return false;
559 }
560
561 bool DInstance::GetUint64(
562 const String& name,
563 Uint64& a,
564 bool& null,
565 bool& key) const
566 {
567 MI_Value v;
568 mike 1.1
569 if (GetValueAsType(name, &v, MI_UINT64, null, key) == MI_RESULT_OK)
570 {
571 a = Uint64(v.uint64);
572 return true;
573 }
574 return false;
575 }
576
577 bool DInstance::GetUint64A(
578 const String& name,
579 Uint64A& a,
580 bool& null,
581 bool& key) const
582 {
583 MI_Value v;
584
585 if (GetValueAsType(name, &v, MI_UINT64A, null, key) == MI_RESULT_OK)
586 {
587 a = Uint64A((Uint64*)v.uint64a.data, v.uint64a.size);
588 return true;
589 mike 1.1 }
590 return false;
591 }
592
593 bool DInstance::GetSint64(
594 const String& name,
595 Sint64& a,
596 bool& null,
597 bool& key) const
598 {
599 MI_Value v;
600
601 if (GetValueAsType(name, &v, MI_SINT64, null, key) == MI_RESULT_OK)
602 {
603 a = Sint64(v.sint64);
604 return true;
605 }
606 return false;
607 }
608
609 bool DInstance::GetSint64A(
610 mike 1.1 const String& name,
611 Sint64A& a,
612 bool& null,
613 bool& key) const
614 {
615 MI_Value v;
616
617 if (GetValueAsType(name, &v, MI_SINT64A, null, key) == MI_RESULT_OK)
618 {
619 a = Sint64A((Sint64*)v.sint64a.data, v.sint64a.size);
620 return true;
621 }
622 return false;
623 }
624
625 bool DInstance::GetReal32(
626 const String& name,
627 Real32& a,
628 bool& null,
629 bool& key) const
630 {
631 mike 1.1 MI_Value v;
632
633 if (GetValueAsType(name, &v, MI_REAL32, null, key) == MI_RESULT_OK)
634 {
635 a = Real32(v.real32);
636 return true;
637 }
638 return false;
639 }
640
641 bool DInstance::GetReal32A(
642 const String& name,
643 Real32A& a,
644 bool& null,
645 bool& key) const
646 {
647 MI_Value v;
648
649 if (GetValueAsType(name, &v, MI_REAL32A, null, key) == MI_RESULT_OK)
650 {
651 a = Real32A((Real32*)v.real32a.data, v.real32a.size);
652 mike 1.1 return true;
653 }
654 return false;
655 }
656
657 bool DInstance::GetReal64(
658 const String& name,
659 Real64& a,
660 bool& null,
661 bool& key) const
662 {
663 MI_Value v;
664
665 if (GetValueAsType(name, &v, MI_REAL64, null, key) == MI_RESULT_OK)
666 {
667 a = Real64(v.real64);
668 return true;
669 }
670 return false;
671 }
672
673 mike 1.1 bool DInstance::GetReal64A(
674 const String& name,
675 Real64A& a,
676 bool& null,
677 bool& key) const
678 {
679 MI_Value v;
680
681 if (GetValueAsType(name, &v, MI_REAL64A, null, key) == MI_RESULT_OK)
682 {
683 a = Real64A((Real64*)v.real64a.data, v.real64a.size);
684 return true;
685 }
686 return false;
687 }
688
689 bool DInstance::GetChar16(
690 const String& name,
691 Char16& a,
692 bool& null,
693 bool& key) const
694 mike 1.1 {
695 MI_Value v;
696
697 if (GetValueAsType(name, &v, MI_CHAR16, null, key) == MI_RESULT_OK)
698 {
699 a = Char16(v.char16);
700 return true;
701 }
702 return false;
703 }
704
705 bool DInstance::GetChar16A(
706 const String& name,
707 Char16A& a,
708 bool& null,
709 bool& key) const
710 {
711 MI_Value v;
712
713 if (GetValueAsType(name, &v, MI_CHAR16A, null, key) == MI_RESULT_OK)
714 {
715 mike 1.1 a = Char16A((Char16*)v.char16a.data, v.char16a.size);
716 return true;
717 }
718 return false;
719 }
720
721 bool DInstance::GetDatetime(
722 const String& name,
723 Datetime& a,
724 bool& null,
725 bool& key) const
726 {
727 MI_Value v;
728
729 if (GetValueAsType(name, &v, MI_DATETIME, null, key) == MI_RESULT_OK)
730 {
731 a = Datetime(v.datetime);
732 return true;
733 }
734 return false;
735 }
736 mike 1.1
737 bool DInstance::GetDatetimeA(
738 const String& name,
739 DatetimeA& a,
740 bool& null,
741 bool& key) const
742 {
743 MI_Value v;
744
745 if (GetValueAsType(name, &v, MI_DATETIMEA, null, key) == MI_RESULT_OK)
746 {
747 a = DatetimeA((Datetime*)v.datetimea.data, v.datetimea.size);
748 return true;
749 }
750 return false;
751 }
752
753 bool DInstance::GetString(
754 const String& name,
755 String& a,
756 bool& null,
757 mike 1.1 bool& key) const
758 {
759 MI_Value v;
760
761 if (GetValueAsType(name, &v, MI_STRING, null, key) == MI_RESULT_OK)
762 {
763 a = String(v.string);
764 return true;
765 }
766 return false;
767 }
768
769 bool DInstance::GetStringA(
770 const String& name,
771 StringA& a,
772 bool& null,
773 bool& key) const
774 {
775 MI_Value v;
776
777 if (GetValueAsType(name, &v, MI_STRINGA, null, key) == MI_RESULT_OK)
778 mike 1.1 {
779 a.Clear();
780 for (MI_Uint32 i = 0; i < v.stringa.size; i++)
781 a.PushBack(v.stringa.data[i]);
782 return true;
783 }
784 return false;
785 }
786
787 bool DInstance::GetReference(
788 const String& name,
789 DInstance& a,
790 bool& null,
791 bool& key) const
792 {
793 MI_Value v;
794
795 if (GetValueAsType(name, &v, MI_REFERENCE, null, key) == MI_RESULT_OK)
796 {
797 __MI_Instance_Ref(v.reference);
798 a = DInstance(v.reference, ADOPT);
799 mike 1.1 return true;
800 }
801 return false;
802 }
803
804 bool DInstance::GetReferenceA(
805 const String& name,
806 DInstanceA& a,
807 bool& null,
808 bool& key) const
809 {
810 MI_Value v;
811
812 if (GetValueAsType(name, &v, MI_REFERENCEA, null, key) == MI_RESULT_OK)
813 {
814 a.Clear();
815 for (MI_Uint32 i = 0; i < v.referencea.size; i++)
816 {
817 MI_Instance* tmp = v.referencea.data[i];
818 __MI_Instance_Ref(tmp);
819 a.PushBack(DInstance(tmp, ADOPT));
820 mike 1.1 }
821 return true;
822 }
823 return false;
824 }
825
826 bool DInstance::GetInstance(
827 const String& name,
828 DInstance& a,
829 bool& null,
830 bool& key) const
831 {
832 MI_Value v;
833
834 if (GetValueAsType(name, &v, MI_INSTANCE, null, key) == MI_RESULT_OK)
835 {
836 __MI_Instance_Ref(v.instance);
837 a = DInstance(v.instance, ADOPT);
838 return true;
839 }
840 return false;
841 mike 1.1 }
842
843 bool DInstance::GetInstanceA(
844 const String& name,
845 DInstanceA& a,
846 bool& null,
847 bool& key) const
848 {
849 MI_Value v;
850
851 if (GetValueAsType(name, &v, MI_INSTANCEA, null, key) == MI_RESULT_OK)
852 {
853 a.Clear();
854
855 for (MI_Uint32 i = 0; i < v.instancea.size; i++)
856 {
857 MI_Instance* tmp = v.instancea.data[i];
858 __MI_Instance_Ref(tmp);
859 a.PushBack(DInstance(tmp, ADOPT));
860 }
861 }
862 mike 1.1 return false;
863 }
864
865 bool DInstance::DynamicToStatic(
866 const DInstance& dinst,
867 bool keysOnly,
868 bool ignoreUnknownProperties,
869 Instance& sinst)
870 {
871 if (!sinst.m_instance)
872 {
873 TRACE;
874 return false;
875 }
876
877 const MI_ClassDecl* cd = sinst.m_instance->classDecl;
878
879 if (!cd)
880 {
881 TRACE;
882 return false;
883 mike 1.1 }
884
885 // Get the property count.
886 Uint32 count;
887
888 if (MI_Instance_GetElementCount(dinst.m_self, &count) != MI_RESULT_OK)
889 {
890 TRACE;
891 return false;
892 }
893
894 // For each property in the dynamic instance.
895 for (Uint32 i = 0; i < count; i++)
896 {
897 const MI_Char* name;
898 MI_Value value;
899 MI_Type type;
900 MI_Uint32 flags;
901
902 // Get the i-th property.
903 if (MI_Instance_GetElementAt(
904 mike 1.1 dinst.m_self, i, &name, &value, &type, &flags) != MI_RESULT_OK)
905 {
906 TRACE;
907 return false;
908 }
909
910 // Find the index of the property with same name in target instance.
911 MI_PropertyDecl* pd;
912 {
913 MI_Uint32 index = _FindPropertyDecl(cd, name);
914
915 if (index == (MI_Uint32)-1)
916 {
917 if (ignoreUnknownProperties)
918 continue;
919
920 TRACE;
921 return false;
922 }
923
924 pd = cd->properties[index];
925 mike 1.1 }
926
927 // Get offset to field:
928 size_t off = pd->offset;
929
930 // Skip non-key properties if so requested.
931 if (!(pd->flags & MI_FLAG_KEY) && keysOnly)
932 {
933 continue;
934 }
935
936 // Set the property in the target instanced.
937 if (type == (MI_Type)pd->type)
938 {
939 if (flags & MI_FLAG_NULL)
940 {
941 switch (type)
942 {
943 case MI_BOOLEAN:
944 {
945 sinst.GetField<Boolean>(off).Clear();
946 mike 1.1 break;
947 }
948 case MI_BOOLEANA:
949 sinst.GetField<BooleanA>(off).Clear();
950 break;
951 case MI_UINT8:
952 sinst.GetField<Uint8>(off).Clear();
953 break;
954 case MI_UINT8A:
955 sinst.GetField<Uint8A>(off).Clear();
956 break;
957 case MI_SINT8:
958 sinst.GetField<Sint8>(off).Clear();
959 break;
960 case MI_SINT8A:
961 sinst.GetField<Sint8A>(off).Clear();
962 break;
963 case MI_UINT16:
964 sinst.GetField<Uint16>(off).Clear();
965 break;
966 case MI_UINT16A:
967 mike 1.1 sinst.GetField<Uint16A>(off).Clear();
968 break;
969 case MI_SINT16:
970 sinst.GetField<Sint16>(off).Clear();
971 break;
972 case MI_SINT16A:
973 sinst.GetField<Sint16A>(off).Clear();
974 break;
975 case MI_UINT32:
976 sinst.GetField<Uint32>(off).Clear();
977 break;
978 case MI_UINT32A:
979 sinst.GetField<Uint32A>(off).Clear();
980 break;
981 case MI_SINT32:
982 sinst.GetField<Sint32>(off).Clear();
983 break;
984 case MI_SINT32A:
985 sinst.GetField<Sint32A>(off).Clear();
986 break;
987 case MI_UINT64:
988 mike 1.1 sinst.GetField<Uint64>(off).Clear();
989 break;
990 case MI_UINT64A:
991 sinst.GetField<Uint64A>(off).Clear();
992 break;
993 case MI_SINT64:
994 sinst.GetField<Sint64>(off).Clear();
995 break;
996 case MI_SINT64A:
997 sinst.GetField<Sint64A>(off).Clear();
998 break;
999 case MI_REAL32:
1000 sinst.GetField<Real32>(off).Clear();
1001 break;
1002 case MI_REAL32A:
1003 sinst.GetField<Real32A>(off).Clear();
1004 break;
1005 case MI_REAL64:
1006 sinst.GetField<Real64>(off).Clear();
1007 break;
1008 case MI_REAL64A:
1009 mike 1.1 sinst.GetField<Real64A>(off).Clear();
1010 break;
1011 case MI_CHAR16:
1012 sinst.GetField<Char16>(off).Clear();
1013 break;
1014 case MI_CHAR16A:
1015 sinst.GetField<Char16A>(off).Clear();
1016 break;
1017 case MI_DATETIME:
1018 sinst.GetField<Datetime>(off).Clear();
1019 break;
1020 case MI_DATETIMEA:
1021 sinst.GetField<DatetimeA>(off).Clear();
1022 break;
1023 case MI_STRING:
1024 sinst.GetField<String>(off).Clear();
1025 break;
1026 case MI_STRINGA:
1027 sinst.GetField<StringA>(off).Clear();
1028 break;
1029 case MI_REFERENCE:
1030 mike 1.1 case MI_INSTANCE:
1031 sinst.GetField<Instance>(off).Clear();
1032 break;
1033 case MI_REFERENCEA:
1034 case MI_INSTANCEA:
1035 sinst.GetField<InstanceA>(off).Clear();
1036 break;
1037 }
1038 }
1039 else
1040 {
1041 switch (type)
1042 {
1043 case MI_BOOLEAN:
1044 sinst.GetField<Uint8>(off).Set(value.uint8);
1045 break;
1046 case MI_UINT8:
1047 sinst.GetField<Uint8>(off).Set(value.uint8);
1048 break;
1049 case MI_SINT8:
1050 sinst.GetField<Sint8>(off).Set(value.sint8);
1051 mike 1.1 break;
1052 case MI_UINT16:
1053 sinst.GetField<Uint16>(off).Set(value.uint16);
1054 break;
1055 case MI_SINT16:
1056 sinst.GetField<Sint16>(off).Set(value.sint16);
1057 break;
1058 case MI_UINT32:
1059 sinst.GetField<Uint32>(off).Set(value.uint32);
1060 break;
1061 case MI_SINT32:
1062 sinst.GetField<Sint32>(off).Set(value.sint32);
1063 break;
1064 case MI_UINT64:
1065 sinst.GetField<Uint64>(off).Set(value.uint64);
1066 break;
1067 case MI_SINT64:
1068 sinst.GetField<Sint64>(off).Set(value.sint64);
1069 break;
1070 case MI_REAL32:
1071 sinst.GetField<Real32>(off).Set(value.real32);
1072 mike 1.1 break;
1073 case MI_REAL64:
1074 sinst.GetField<Real64>(off).Set(value.real64);
1075 break;
1076 case MI_CHAR16:
1077 sinst.GetField<Char16>(off).Set(value.char16);
1078 break;
1079 case MI_DATETIME:
1080 sinst.GetField<Datetime>(off).Set(value.datetime);
1081 break;
1082 case MI_STRING:
1083 sinst.GetField<String>(off).Set(value.string);
1084 break;
1085 case MI_REFERENCE:
1086 case MI_INSTANCE:
1087 {
1088 if (!value.instance)
1089 {
1090 TRACE;
1091 return false;
1092 }
1093 mike 1.1
1094 const MI_ClassDecl* tcd = SchemaDecl_FindClassDecl(
1095 cd->schema, pd->className);
1096
1097 if (!tcd)
1098 {
1099 TRACE;
1100 return false;
1101 }
1102
1103 // ATTN: optimize: avoid cloning.
1104 DInstance tdinst(value.instance, CLONE);
1105 Instance x(tcd);
1106
1107 if (!DynamicToStatic(tdinst, keysOnly,
1108 ignoreUnknownProperties, x))
1109 {
1110 TRACE;
1111 return false;
1112 }
1113
1114 mike 1.1 sinst.GetField<Instance>(off).Set(x);
1115 break;
1116 }
1117 case MI_BOOLEANA:
1118 {
1119 BooleanA a(value.booleana.data, value.booleana.size);
1120 sinst.GetField<BooleanA>(off).Set(a);
1121 break;
1122 }
1123 case MI_UINT8A:
1124 {
1125 Uint8A a(value.uint8a.data, value.uint8a.size);
1126 sinst.GetField<Uint8A>(off).Set(a);
1127 break;
1128 }
1129 case MI_SINT8A:
1130 {
1131 Sint8A a(value.sint8a.data, value.sint8a.size);
1132 sinst.GetField<Sint8A>(off).Set(a);
1133 break;
1134 }
1135 mike 1.1 case MI_UINT16A:
1136 {
1137 Uint16A a(value.uint16a.data, value.uint16a.size);
1138 sinst.GetField<Uint16A>(off).Set(a);
1139 break;
1140 }
1141 case MI_SINT16A:
1142 {
1143 Sint16A a(value.sint16a.data, value.sint16a.size);
1144 sinst.GetField<Sint16A>(off).Set(a);
1145 break;
1146 }
1147 case MI_UINT32A:
1148 {
1149 Uint32A a(value.uint32a.data, value.uint32a.size);
1150 sinst.GetField<Uint32A>(off).Set(a);
1151 break;
1152 }
1153 case MI_SINT32A:
1154 {
1155 Sint32A a(value.sint32a.data, value.sint32a.size);
1156 mike 1.1 sinst.GetField<Sint32A>(off).Set(a);
1157 break;
1158 }
1159 case MI_UINT64A:
1160 {
1161 Uint64A a(value.uint64a.data, value.uint64a.size);
1162 sinst.GetField<Uint64A>(off).Set(a);
1163 break;
1164 }
1165 case MI_SINT64A:
1166 {
1167 Sint64A a(value.sint64a.data, value.sint64a.size);
1168 sinst.GetField<Sint64A>(off).Set(a);
1169 break;
1170 }
1171 case MI_REAL32A:
1172 {
1173 Real32A a(value.real32a.data, value.real32a.size);
1174 sinst.GetField<Real32A>(off).Set(a);
1175 break;
1176 }
1177 mike 1.1 case MI_REAL64A:
1178 {
1179 Real64A a(value.real64a.data, value.real64a.size);
1180 sinst.GetField<Real64A>(off).Set(a);
1181 break;
1182 }
1183 case MI_CHAR16A:
1184 {
1185 Char16A a(value.char16a.data, value.char16a.size);
1186 sinst.GetField<Char16A>(off).Set(a);
1187 break;
1188 }
1189 case MI_DATETIMEA:
1190 {
1191 DatetimeA a(
1192 reinterpret_cast<Datetime*>(value.datetimea.data),
1193 value.datetimea.size);
1194 sinst.GetField<DatetimeA>(off).Set(a);
1195 break;
1196 }
1197 case MI_STRINGA:
1198 mike 1.1 {
1199 StringA a;
1200
1201 for (Uint32 j = 0; j < value.stringa.size; j++)
1202 a.PushBack(String(value.stringa.data[j]));
1203
1204 sinst.GetField<StringA>(off).Set(a);
1205 break;
1206 }
1207 case MI_REFERENCEA:
1208 case MI_INSTANCEA:
1209 {
1210 if (!value.instancea.data)
1211 {
1212 TRACE;
1213 return false;
1214 }
1215
1216 const MI_ClassDecl* tcd = SchemaDecl_FindClassDecl(
1217 cd->schema, pd->className);
1218
1219 mike 1.1 if (!tcd)
1220 {
1221 TRACE;
1222 return false;
1223 }
1224
1225 InstanceA a;
1226
1227 for (Uint32 j = 0; j < value.instancea.size; j++)
1228 {
1229 if (!value.instancea.data[j])
1230 {
1231 TRACE;
1232 return false;
1233 }
1234
1235 DInstance tdinst(value.instancea.data[j], CLONE);
1236 Instance x(tcd);
1237
1238 if (!DynamicToStatic(tdinst, keysOnly,
1239 ignoreUnknownProperties, x))
1240 mike 1.1 {
1241 TRACE;
1242 return false;
1243 }
1244
1245 a.PushBack(x);
1246 }
1247
1248 sinst.GetField<InstanceA>(off).Set(a);
1249 break;
1250 }
1251 }
1252 }
1253 }
1254 else if (type == MI_STRING)
1255 {
1256 // Convert string to type of target property.
1257 switch (pd->type)
1258 {
1259 case MI_BOOLEAN:
1260 {
1261 mike 1.1 Boolean x;
1262
1263 if (StrToBoolean(value.string, &x) != 0)
1264 return false;
1265
1266 sinst.GetField<Boolean>(off).Set(x);
1267 break;
1268 }
1269 case MI_UINT8:
1270 {
1271 Uint8 x;
1272
1273 if (StrToUint8(value.string, &x) != 0)
1274 return false;
1275
1276 sinst.GetField<Uint8>(off).Set(x);
1277 break;
1278 }
1279 case MI_SINT8:
1280 {
1281 Sint8 x;
1282 mike 1.1
1283 if (StrToSint8(value.string, &x) != 0)
1284 return false;
1285
1286 sinst.GetField<Sint8>(off).Set(x);
1287 break;
1288 }
1289 case MI_UINT16:
1290 {
1291 Uint16 x;
1292
1293 if (StrToUint16(value.string, &x) != 0)
1294 return false;
1295
1296 sinst.GetField<Uint16>(off).Set(x);
1297 break;
1298 }
1299 case MI_SINT16:
1300 {
1301 Sint16 x;
1302
1303 mike 1.1 if (StrToSint16(value.string, &x) != 0)
1304 return false;
1305
1306 sinst.GetField<Sint16>(off).Set(x);
1307 break;
1308 }
1309 case MI_UINT32:
1310 {
1311 Uint32 x;
1312
1313 if (StrToUint32(value.string, &x) != 0)
1314 return false;
1315
1316 sinst.GetField<Uint32>(off).Set(x);
1317 break;
1318 }
1319 case MI_SINT32:
1320 {
1321 Sint32 x;
1322
1323 if (StrToSint32(value.string, &x) != 0)
1324 mike 1.1 return false;
1325
1326 sinst.GetField<Sint32>(off).Set(x);
1327 break;
1328 }
1329 case MI_UINT64:
1330 {
1331 Uint64 x;
1332
1333 if (StrToUint64(value.string, &x) != 0)
1334 return false;
1335
1336 sinst.GetField<Uint64>(off).Set(x);
1337 break;
1338 }
1339 case MI_SINT64:
1340 {
1341 Sint64 x;
1342
1343 if (StrToSint64(value.string, &x) != 0)
1344 return false;
1345 mike 1.1
1346 sinst.GetField<Sint64>(off).Set(x);
1347 break;
1348 }
1349 case MI_REAL32:
1350 {
1351 Real32 x;
1352
1353 if (StrToReal32(value.string, &x) != 0)
1354 return false;
1355
1356 sinst.GetField<Real32>(off).Set(x);
1357 break;
1358 }
1359 case MI_REAL64:
1360 {
1361 Real64 x;
1362
1363 if (StrToReal64(value.string, &x) != 0)
1364 return false;
1365
1366 mike 1.1 sinst.GetField<Real64>(off).Set(x);
1367 break;
1368 }
1369 case MI_CHAR16:
1370 {
1371 Char16 x;
1372
1373 if (StrToChar16(value.string, &x) != 0)
1374 return false;
1375
1376 sinst.GetField<Char16>(off).Set(x);
1377 break;
1378 }
1379 case MI_DATETIME:
1380 {
1381 MI_Datetime x;
1382
1383 if (StrToDatetime(value.string, &x) != 0)
1384 return false;
1385
1386 sinst.GetField<Datetime>(off).Set(Datetime(x));
1387 mike 1.1 break;
1388 }
1389 default:
1390 {
1391 // Conversion to string to this type is unsupported!
1392 return false;
1393 }
1394 }
1395 }
1396 else if (type == MI_STRINGA)
1397 {
1398 switch (pd->type)
1399 {
1400 case MI_BOOLEANA:
1401 {
1402 Array<Boolean> a;
1403
1404 for (Uint32 j = 0; j < value.stringa.size; j++)
1405 {
1406 MI_Boolean x;
1407
1408 mike 1.1 if (StrToBoolean(value.stringa.data[j], &x) != 0)
1409 return false;
1410
1411 a.PushBack(x);
1412 }
1413
1414 sinst.GetField<BooleanA>(off).Set(a);
1415 break;
1416 }
1417 case MI_UINT8A:
1418 {
1419 Array<Uint8> a;
1420
1421 for (Uint32 j = 0; j < value.stringa.size; j++)
1422 {
1423 MI_Uint8 x;
1424
1425 if (StrToUint8(value.stringa.data[j], &x) != 0)
1426 return false;
1427
1428 a.PushBack(x);
1429 mike 1.1 }
1430
1431 sinst.GetField<Uint8A>(off).Set(a);
1432 break;
1433 }
1434 case MI_SINT8A:
1435 {
1436 Array<Sint8> a;
1437
1438 for (Uint32 j = 0; j < value.stringa.size; j++)
1439 {
1440 MI_Sint8 x;
1441
1442 if (StrToSint8(value.stringa.data[j], &x) != 0)
1443 return false;
1444
1445 a.PushBack(x);
1446 }
1447
1448 sinst.GetField<Sint8A>(off).Set(a);
1449 break;
1450 mike 1.1 }
1451 case MI_UINT16A:
1452 {
1453 Array<Uint16> a;
1454
1455 for (Uint32 j = 0; j < value.stringa.size; j++)
1456 {
1457 MI_Uint16 x;
1458
1459 if (StrToUint16(value.stringa.data[j], &x) != 0)
1460 return false;
1461
1462 a.PushBack(x);
1463 }
1464
1465 sinst.GetField<Uint16A>(off).Set(a);
1466 break;
1467 }
1468 case MI_SINT16A:
1469 {
1470 Array<Sint16> a;
1471 mike 1.1
1472 for (Uint32 j = 0; j < value.stringa.size; j++)
1473 {
1474 MI_Sint16 x;
1475
1476 if (StrToSint16(value.stringa.data[j], &x) != 0)
1477 return false;
1478
1479 a.PushBack(x);
1480 }
1481
1482 sinst.GetField<Sint16A>(off).Set(a);
1483 break;
1484 }
1485 case MI_UINT32A:
1486 {
1487 Array<Uint32> a;
1488
1489 for (Uint32 j = 0; j < value.stringa.size; j++)
1490 {
1491 MI_Uint32 x;
1492 mike 1.1
1493 if (StrToUint32(value.stringa.data[j], &x) != 0)
1494 return false;
1495
1496 a.PushBack(x);
1497 }
1498
1499 sinst.GetField<Uint32A>(off).Set(a);
1500 break;
1501 }
1502 case MI_SINT32A:
1503 {
1504 Array<Sint32> a;
1505
1506 for (Uint32 j = 0; j < value.stringa.size; j++)
1507 {
1508 MI_Sint32 x;
1509
1510 if (StrToSint32(value.stringa.data[j], &x) != 0)
1511 return false;
1512
1513 mike 1.1 a.PushBack(x);
1514 }
1515
1516 sinst.GetField<Sint32A>(off).Set(a);
1517 break;
1518 }
1519 case MI_UINT64A:
1520 {
1521 Array<Uint64> a;
1522
1523 for (Uint32 j = 0; j < value.stringa.size; j++)
1524 {
1525 MI_Uint64 x;
1526
1527 if (StrToUint64(value.stringa.data[j], &x) != 0)
1528 return false;
1529
1530 a.PushBack(x);
1531 }
1532
1533 sinst.GetField<Uint64A>(off).Set(a);
1534 mike 1.1 break;
1535 }
1536 case MI_SINT64A:
1537 {
1538 Array<Sint64> a;
1539
1540 for (Uint32 j = 0; j < value.stringa.size; j++)
1541 {
1542 MI_Sint64 x;
1543
1544 if (StrToSint64(value.stringa.data[j], &x) != 0)
1545 return false;
1546
1547 a.PushBack(x);
1548 }
1549
1550 sinst.GetField<Sint64A>(off).Set(a);
1551 break;
1552 }
1553 case MI_REAL32A:
1554 {
1555 mike 1.1 Array<Real32> a;
1556
1557 for (Uint32 j = 0; j < value.stringa.size; j++)
1558 {
1559 MI_Real32 x;
1560
1561 if (StrToReal32(value.stringa.data[j], &x) != 0)
1562 return false;
1563
1564 a.PushBack(x);
1565 }
1566
1567 sinst.GetField<Real32A>(off).Set(a);
1568 break;
1569 }
1570 case MI_REAL64A:
1571 {
1572 Array<Real64> a;
1573
1574 for (Uint32 j = 0; j < value.stringa.size; j++)
1575 {
1576 mike 1.1 MI_Real64 x;
1577
1578 if (StrToReal64(value.stringa.data[j], &x) != 0)
1579 return false;
1580
1581 a.PushBack(x);
1582 }
1583
1584 sinst.GetField<Real64A>(off).Set(a);
1585 break;
1586 }
1587 case MI_CHAR16A:
1588 {
1589 Array<Char16> a;
1590
1591 for (Uint32 j = 0; j < value.stringa.size; j++)
1592 {
1593 MI_Char16 x;
1594
1595 if (StrToChar16(value.stringa.data[j], &x) != 0)
1596 return false;
1597 mike 1.1
1598 a.PushBack(x);
1599 }
1600
1601 sinst.GetField<Char16A>(off).Set(a);
1602 break;
1603 }
1604 case MI_DATETIMEA:
1605 {
1606 Array<Datetime> a;
1607
1608 for (Uint32 j = 0; j < value.stringa.size; j++)
1609 {
1610 MI_Datetime x;
1611
1612 if (StrToDatetime(value.stringa.data[j], &x) != 0)
1613 return false;
1614
1615 a.PushBack(x);
1616 }
1617
1618 mike 1.1 sinst.GetField<DatetimeA>(off).Set(a);
1619 break;
1620 }
1621 default:
1622 {
1623 // Conversion to string to this type is unsupported!
1624 return false;
1625 }
1626 }
1627 }
1628 else
1629 {
1630 return false;
1631 }
1632 }
1633
1634 return true;
1635 }
1636
1637 bool DInstance::StaticToDynamic(
1638 const Instance& sinst,
1639 mike 1.1 bool keysOnly,
1640 DInstance& dinst)
1641 {
1642 // Reject if static instance has no internal instance.
1643 if (!sinst.m_instance)
1644 {
1645 TRACE;
1646 return false;
1647 }
1648
1649 // Get class declaration from static instance.
1650 const MI_ClassDecl* cd = sinst.m_instance->classDecl;
1651 if (!cd)
1652 {
1653 TRACE;
1654 return false;
1655 }
1656
1657 // Create new instance with given class name.
1658 {
1659 MetaType mt;
1660 mike 1.1 memset(&mt, 0, sizeof(mt));
1661
1662 if (cd->flags & MI_FLAG_ASSOCIATION)
1663 mt = ASSOCIATION;
1664 else if (cd->flags & MI_FLAG_INDICATION)
1665 mt = INDICATION;
1666 else if (cd->flags & MI_FLAG_METHOD)
1667 mt = METHOD;
1668 else if (cd->flags & MI_FLAG_CLASS)
1669 mt = CLASS;
1670
1671 dinst = DInstance(cd->name, mt);
1672 }
1673
1674 // Convert each property.
1675 for (Uint32 i = 0; i < cd->numProperties; i++)
1676 {
1677 MI_PropertyDecl* pd = cd->properties[i];
1678 bool key = (pd->flags & MI_FLAG_KEY) != 0;
1679
1680 if (!key && keysOnly)
1681 mike 1.1 continue;
1682
1683 switch (pd->type)
1684 {
1685 case MI_BOOLEAN:
1686 {
1687 dinst.AddBoolean(
1688 pd->name,
1689 sinst.GetField<Boolean>(pd->offset).value,
1690 !sinst.GetField<Boolean>(pd->offset).exists,
1691 key);
1692 break;
1693 }
1694 case MI_UINT8:
1695 {
1696 dinst.AddUint8(
1697 pd->name,
1698 sinst.GetField<Uint8>(pd->offset).value,
1699 !sinst.GetField<Uint8>(pd->offset).exists,
1700 key);
1701 break;
1702 mike 1.1 }
1703 case MI_SINT8:
1704 {
1705 dinst.AddSint8(
1706 pd->name,
1707 sinst.GetField<Sint8>(pd->offset).value,
1708 !sinst.GetField<Sint8>(pd->offset).exists,
1709 key);
1710 break;
1711 }
1712 case MI_UINT16:
1713 {
1714 dinst.AddUint16(
1715 pd->name,
1716 sinst.GetField<Uint16>(pd->offset).value,
1717 !sinst.GetField<Uint16>(pd->offset).exists,
1718 key);
1719 break;
1720 }
1721 case MI_SINT16:
1722 {
1723 mike 1.1 dinst.AddSint16(
1724 pd->name,
1725 sinst.GetField<Sint16>(pd->offset).value,
1726 !sinst.GetField<Sint16>(pd->offset).exists,
1727 key);
1728 break;
1729 }
1730 case MI_UINT32:
1731 {
1732 dinst.AddUint32(
1733 pd->name,
1734 sinst.GetField<Uint32>(pd->offset).value,
1735 !sinst.GetField<Uint32>(pd->offset).exists,
1736 key);
1737 break;
1738 }
1739 case MI_SINT32:
1740 {
1741 dinst.AddSint32(
1742 pd->name,
1743 sinst.GetField<Sint32>(pd->offset).value,
1744 mike 1.1 !sinst.GetField<Sint32>(pd->offset).exists,
1745 key);
1746 break;
1747 }
1748 case MI_UINT64:
1749 {
1750 dinst.AddUint64(
1751 pd->name,
1752 sinst.GetField<Uint64>(pd->offset).value,
1753 !sinst.GetField<Uint64>(pd->offset).exists,
1754 key);
1755 break;
1756 }
1757 case MI_SINT64:
1758 {
1759 dinst.AddSint64(
1760 pd->name,
1761 sinst.GetField<Sint64>(pd->offset).value,
1762 !sinst.GetField<Sint64>(pd->offset).exists,
1763 key);
1764 break;
1765 mike 1.1 }
1766 case MI_REAL32:
1767 {
1768 dinst.AddReal32(
1769 pd->name,
1770 sinst.GetField<Real32>(pd->offset).value,
1771 !sinst.GetField<Real32>(pd->offset).exists,
1772 key);
1773 break;
1774 }
1775 case MI_REAL64:
1776 {
1777 dinst.AddReal64(
1778 pd->name,
1779 sinst.GetField<Real64>(pd->offset).value,
1780 !sinst.GetField<Real64>(pd->offset).exists,
1781 key);
1782 break;
1783 }
1784 case MI_CHAR16:
1785 {
1786 mike 1.1 dinst.AddChar16(
1787 pd->name,
1788 sinst.GetField<Char16>(pd->offset).value,
1789 !sinst.GetField<Char16>(pd->offset).exists,
1790 key);
1791 break;
1792 }
1793 case MI_DATETIME:
1794 {
1795 dinst.AddDatetime(
1796 pd->name,
1797 sinst.GetField<Datetime>(pd->offset).value,
1798 !sinst.GetField<Datetime>(pd->offset).exists,
1799 key);
1800 break;
1801 }
1802 case MI_STRING:
1803 {
1804 dinst.AddString(
1805 pd->name,
1806 sinst.GetField<String>(pd->offset).value,
1807 mike 1.1 !sinst.GetField<String>(pd->offset).exists,
1808 key);
1809 break;
1810 }
1811 case MI_REFERENCE:
1812 case MI_INSTANCE:
1813 {
1814 DInstance x;
1815
1816 if (!DInstance::StaticToDynamic(
1817 sinst.GetField<Instance>(pd->offset).value,
1818 keysOnly,
1819 x))
1820 {
1821 return false;
1822 }
1823
1824 dinst.AddInstance(
1825 pd->name,
1826 x,
1827 !sinst.GetField<Instance>(pd->offset).exists,
1828 mike 1.1 key);
1829 break;
1830 }
1831 case MI_BOOLEANA:
1832 {
1833 dinst.AddBooleanA(
1834 pd->name,
1835 sinst.GetField<BooleanA>(pd->offset).value,
1836 !sinst.GetField<BooleanA>(pd->offset).exists,
1837 key);
1838 break;
1839 }
1840 case MI_UINT8A:
1841 {
1842 dinst.AddUint8A(
1843 pd->name,
1844 sinst.GetField<Uint8A>(pd->offset).value,
1845 !sinst.GetField<Uint8A>(pd->offset).exists,
1846 key);
1847 break;
1848 }
1849 mike 1.1 case MI_SINT8A:
1850 {
1851 dinst.AddSint8A(
1852 pd->name,
1853 sinst.GetField<Sint8A>(pd->offset).value,
1854 !sinst.GetField<Sint8A>(pd->offset).exists,
1855 key);
1856 break;
1857 }
1858 case MI_UINT16A:
1859 {
1860 dinst.AddUint16A(
1861 pd->name,
1862 sinst.GetField<Uint16A>(pd->offset).value,
1863 !sinst.GetField<Uint16A>(pd->offset).exists,
1864 key);
1865 break;
1866 }
1867 case MI_SINT16A:
1868 {
1869 dinst.AddSint16A(
1870 mike 1.1 pd->name,
1871 sinst.GetField<Sint16A>(pd->offset).value,
1872 !sinst.GetField<Sint16A>(pd->offset).exists,
1873 key);
1874 break;
1875 }
1876 case MI_UINT32A:
1877 {
1878 dinst.AddUint32A(
1879 pd->name,
1880 sinst.GetField<Uint32A>(pd->offset).value,
1881 !sinst.GetField<Uint32A>(pd->offset).exists,
1882 key);
1883 break;
1884 }
1885 case MI_SINT32A:
1886 {
1887 dinst.AddSint32A(
1888 pd->name,
1889 sinst.GetField<Sint32A>(pd->offset).value,
1890 !sinst.GetField<Sint32A>(pd->offset).exists,
1891 mike 1.1 key);
1892 break;
1893 }
1894 case MI_UINT64A:
1895 {
1896 dinst.AddUint64A(
1897 pd->name,
1898 sinst.GetField<Uint64A>(pd->offset).value,
1899 !sinst.GetField<Uint64A>(pd->offset).exists,
1900 key);
1901 break;
1902 }
1903 case MI_SINT64A:
1904 {
1905 dinst.AddSint64A(
1906 pd->name,
1907 sinst.GetField<Sint64A>(pd->offset).value,
1908 !sinst.GetField<Sint64A>(pd->offset).exists,
1909 key);
1910 break;
1911 }
1912 mike 1.1 case MI_REAL32A:
1913 {
1914 dinst.AddReal32A(
1915 pd->name,
1916 sinst.GetField<Real32A>(pd->offset).value,
1917 !sinst.GetField<Real32A>(pd->offset).exists,
1918 key);
1919 break;
1920 }
1921 case MI_REAL64A:
1922 {
1923 dinst.AddReal64A(
1924 pd->name,
1925 sinst.GetField<Real64A>(pd->offset).value,
1926 !sinst.GetField<Real64A>(pd->offset).exists,
1927 key);
1928 break;
1929 }
1930 case MI_CHAR16A:
1931 {
1932 dinst.AddChar16A(
1933 mike 1.1 pd->name,
1934 sinst.GetField<Char16A>(pd->offset).value,
1935 !sinst.GetField<Char16A>(pd->offset).exists,
1936 key);
1937 break;
1938 }
1939 case MI_DATETIMEA:
1940 {
1941 dinst.AddDatetimeA(
1942 pd->name,
1943 sinst.GetField<DatetimeA>(pd->offset).value,
1944 !sinst.GetField<DatetimeA>(pd->offset).exists,
1945 key);
1946 break;
1947 }
1948 case MI_STRINGA:
1949 {
1950 dinst.AddStringA(
1951 pd->name,
1952 sinst.GetField<StringA>(pd->offset).value,
1953 !sinst.GetField<StringA>(pd->offset).exists,
1954 mike 1.1 key);
1955 break;
1956 }
1957 case MI_REFERENCEA:
1958 case MI_INSTANCEA:
1959 {
1960 Array<DInstance> da;
1961 const Array<Instance>& sa =
1962 sinst.GetField<InstanceA>(pd->offset).value;
1963
1964 for (Uint32 index = 0; index < sa.GetSize(); index++)
1965 {
1966 DInstance x;
1967
1968 if (!DInstance::StaticToDynamic( sa[index], keysOnly, x))
1969 return false;
1970
1971 da.PushBack(x);
1972 }
1973
1974 dinst.AddInstanceA(
1975 mike 1.1 pd->name,
1976 da,
1977 !sinst.GetField<InstanceA>(pd->offset).exists,
1978 key);
1979 break;
1980 }
1981 default:
1982 break;
1983 }
1984 }
1985
1986 return true;
1987 }
1988
1989 MI_END_NAMESPACE
|
Return to
dinstance.cpp
CVS log
Up to [OMI] / omi / micxx