Merge branch 'release/1.0'

Author: Anders Modén

Assets/Plugins/x64/gzBase64.dll

@@ -125,6 +125,130 @@ public DynamicType(IntPtr nativeReference) : base(nativeReference) { }
 
             public DynamicType(Reference reference) : base(DynamicType_create_reference(reference.GetNativeReference())) { }
 
+            public static DynamicType CreateDynamicType(object obj)
+            {
+                if (obj == null)
+                    return new DynamicType();
+
+                if (obj is DynamicType)
+                    return obj as DynamicType;
+
+                if(obj is DynamicTypeContainer)
+                    return (DynamicType)(obj as DynamicTypeContainer);
+
+                if (obj is DynamicTypeArray)
+                    return (DynamicType)(obj as DynamicTypeArray);
+
+                if (obj.GetType() == typeof(string))
+                    return new DynamicType((string)obj);
+
+                if (obj.GetType() == typeof(Int64))
+                    return new DynamicTypeInt64((Int64)obj);
+
+                if (obj.GetType() == typeof(UInt64))
+                    return new DynamicTypeInt64((UInt64)obj);
+
+                if (obj.GetType() == typeof(Vec2))
+                    return new DynamicType((Vec2)obj);
+
+                if (obj.GetType() == typeof(Vec3))
+                    return new DynamicType((Vec3)obj);
+
+                if (obj.GetType() == typeof(Vec4))
+                    return new DynamicType((Vec4)obj);
+
+                if (obj.GetType() == typeof(Guid))
+                    return new DynamicType((Guid)obj);
+
+                if (obj.GetType() == typeof(Reference))
+                    return new DynamicType((Reference)obj);
+
+                if (obj.GetType().IsEnum)
+                {
+                    if (Marshal.SizeOf(Enum.GetUnderlyingType(obj.GetType())) <= sizeof(UInt32))
+                        return new DynamicType((UInt32)Convert.ChangeType(obj, typeof(UInt32)));
+                    else
+                        return new DynamicType((UInt64)Convert.ChangeType(obj, typeof(UInt64)));
+                }
+
+                return new DynamicType((double)Convert.ChangeType(obj,typeof(double)));    // default to double
+            }
+
+            public object GetObject(System.Type t)
+            {
+                if (t==typeof(DynamicType))
+                    return this;
+
+                if (t.IsSubclassOf(typeof(DynamicType)))
+                    return this;
+
+                if (t == typeof(DynamicTypeArray))
+                    return (DynamicTypeArray)this;
+
+                if (t.IsSubclassOf(typeof(DynamicTypeArray)))
+                {
+                    object o = Activator.CreateInstance(t);
+
+                    ((DynamicTypeArray)o).Set(this);
+
+                    return o;
+                }
+
+                if (t == typeof(DynamicTypeContainer))
+                    return (DynamicTypeContainer)this;
+
+                if (t.IsSubclassOf(typeof(DynamicTypeContainer)))
+                {
+                    object o=Activator.CreateInstance(t);
+
+                    ((DynamicTypeContainer)o).Set(this);
+                    
+                    return o;
+                }
+                if (t==typeof(string))
+                    return (string)this;
+
+                if (t == typeof(UInt64))
+                    return (UInt64)this;
+
+                if (t == typeof(Int64))
+                    return (Int64)this;
+
+                if (t == typeof(Vec2))
+                    return (Vec2)this;
+
+                if (t == typeof(Vec3))
+                    return (Vec3)this;
+
+                if (t == typeof(Vec4))
+                    return (Vec4)this;
+
+                if (t == typeof(Guid))
+                    return (Guid)this;
+
+                if (t == typeof(Reference))
+                    return (Reference)this;
+                
+                if (t.IsSubclassOf(typeof(Reference)))
+                    return (Reference)this;
+
+                if (t.IsEnum)
+                {
+                    if(Marshal.SizeOf(Enum.GetUnderlyingType(t))<=sizeof(UInt32))
+                        return Enum.ToObject(t, (UInt32)this);
+                    else
+                        return Enum.ToObject(t, (UInt64)this);
+                }
+    
+                return Convert.ChangeType(GetNumber(), t);
+            }
+
+            public bool IsVoid()
+            {
+                return Is("void");
+            }
+
+
             public string GetDynamicType()
             {
                 if (!IsValid())
@@ -154,6 +278,7 @@ public Vec2 GetVec2()
                 if (!IsValid())
                     throw (new Exception("DynamicType is not VALID"));
 
+
                 return DynamicType_getVec2(GetNativeReference());
             }
 
@@ -170,6 +295,9 @@ public Reference GetReference()
                 if (!IsValid())
                     throw (new Exception("DynamicType is not VALID"));
 
+                if (IsVoid())
+                    return null;
+
                 return new Reference(DynamicType_getReference(GetNativeReference()));
             }
 
@@ -192,15 +320,18 @@ public Guid GetGuid()
             public string GetString()
             {
                 if (!IsValid())
-                    return "Invalid";
+                    return null;
+
+                if (IsVoid())
+                    return null;
 
                 return Marshal.PtrToStringUni(DynamicType_getString(GetNativeReference()));
             }
 
             public string AsString(bool stripXML = true, bool skipDynTag = true, string tagName="data")
             {
                 if (!IsValid())
-                    return "Invalid";
+                    return null;
 
                 return Marshal.PtrToStringUni(DynamicType_asString(GetNativeReference(),stripXML,skipDynTag,tagName));
             }

Assets/Plugins/x64/gzBaseBridge64.dll

@@ -105,7 +105,18 @@ public DynamicTypeArray(DynamicType data) : base(DynamicTypeArray_unpack_array(d
                     throw (new Exception("DynamicType is not an ARRAY"));
             }
 
-           
+            public void Set(DynamicType t)
+            {
+                if (t == null)
+                    return;
+
+                if (!t.Is(DynamicType.Type.ARRAY))
+                    return;
+
+                Reset(DynamicTypeArray_unpack_array(t.GetNativeReference()));
+            }
+
+
             public int IndexOf(DynamicType item)
             {
                 return DynamicTypeArray_index_of(GetNativeReference(),item.GetNativeReference());

Assets/Plugins/x64/gzDistribution64.dll

@@ -76,6 +76,9 @@ public static implicit operator DynamicType(DynamicTypeContainer cont)
                 if (cont == null)
                     return null;
 
+                if (cont.GetType().IsDefined(typeof(DynamicTypePropertyAutoStore), true))
+                    cont.StorePropertiesAndFields();
+
                 return new DynamicType(DynamicTypeContainer_pack_cont(cont.GetNativeReference()));
             }
 
@@ -95,8 +98,24 @@ public  DynamicTypeContainer(DynamicType data) : base(DynamicTypeContainer_unpac
 
                 if (GetNativeReference()==IntPtr.Zero)
                     throw (new Exception("DynamicType is not a CONTAINER"));
+                
+            }
+
+            public void Set(DynamicType t)
+            {
+                if (t == null)
+                    return;
+
+                if (!t.Is(DynamicType.Type.CONTAINER))
+                    return;
+
+                Reset(DynamicTypeContainer_unpack_cont(t.GetNativeReference()));
+
+                if (GetType().IsDefined(typeof(DynamicTypePropertyAutoRestore), true))
+                    RestorePropertiesAndFields();
             }
 
+
             public void SetAttribute(string name, DynamicType value)
             {
                 if (name == null)
@@ -129,6 +148,38 @@ public override string ToString()
                 return ((DynamicType)(this)).AsString();
             }
 
+            // --- Reflection mechanisms --------------------------------
+
+            public void StorePropertiesAndFields(bool allProperties = false)
+            {
+                foreach (System.Reflection.PropertyInfo prop in GetType().GetProperties())
+                {
+                    if (allProperties || Attribute.IsDefined(prop, typeof(DynamicTypeProperty)))
+                        SetAttribute(prop.Name, DynamicType.CreateDynamicType(prop.GetValue(this)));
+                }
+
+                foreach (System.Reflection.FieldInfo field in GetType().GetFields())
+                {
+                    if (allProperties || Attribute.IsDefined(field, typeof(DynamicTypeProperty)))
+                        SetAttribute(field.Name, DynamicType.CreateDynamicType(field.GetValue(this)));
+                }
+            }
+
+            public void RestorePropertiesAndFields(bool allProperties = false)
+            {
+                foreach (System.Reflection.PropertyInfo prop in GetType().GetProperties())
+                {
+                    if (allProperties || Attribute.IsDefined(prop, typeof(DynamicTypeProperty)))
+                        prop.SetValue(this, GetAttribute(prop.Name).GetObject(prop.PropertyType));
+                }
+
+                foreach (System.Reflection.FieldInfo field in GetType().GetFields())
+                {
+                    if (allProperties || Attribute.IsDefined(field, typeof(DynamicTypeProperty)))
+                        field.SetValue(this, GetAttribute(field.Name).GetObject(field.FieldType));
+                }
+            }
+
             #region ---------------------- private -------------------------------------
 
             [DllImport(Platform.BRIDGE, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

Assets/Plugins/x64/gzDistributionBridge64.dll

@@ -0,0 +1,47 @@
+//******************************************************************************
+// File			: DynamicTypeProperty.cs
+// Module		: GizmoBase C#
+// Description	: C# Bridge to gzDynamicType property classes
+// Author		: Anders Modén		
+// Product		: GizmoBase 2.10.1
+//		
+// Copyright © 2003- Saab Training Systems AB, Sweden
+//			
+// NOTE:	GizmoBase is a platform abstraction utility layer for C++. It contains 
+//			design patterns and C++ solutions for the advanced programmer.
+//
+//
+// Revision History...							
+//									
+// Who	Date	Description						
+//									
+// AMO	180301	Created file 	
+//
+//******************************************************************************
+
+using System;
+using System.Runtime.InteropServices;
+using GizmoSDK.GizmoBase;
+
+ 
+
+namespace GizmoSDK
+{
+    namespace GizmoBase
+    {
+        [System.AttributeUsage(System.AttributeTargets.Property| System.AttributeTargets.Field, AllowMultiple = false)]
+        public class DynamicTypeProperty : System.Attribute
+        {
+        }
+
+        [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple = false)]
+        public class DynamicTypePropertyAutoStore : System.Attribute
+        {
+        }
+
+        [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple = false)]
+        public class DynamicTypePropertyAutoRestore : System.Attribute
+        {
+        }
+    }
+}