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