public void UTinyObject_FieldRename()
        {
            var @object = new UTinyObject(m_Registry, (UTinyType.Reference)m_TestStruct)
            {
                ["Foo"] = "Test",
                ["Bar"] = 10
            };

            m_TestStruct.Fields[0].Name = "Baz";

            // Dynamic values should be promoted to field values
            @object.Refresh();

            Assert.AreEqual("Test", @object["Baz"]);
            Assert.AreEqual(10, @object["Bar"]);

            Debug.Log(@object.ToString());
        }
        public void UTinyObject_Dynamic_PrimitiveValuePromotion()
        {
            // Untyped dynamic object
            var @object = new UTinyObject(m_Registry, UTinyType.Reference.None)
            {
                ["Foo"] = "Test",
                ["Bar"] = 10
            };

            // Assign a type to it
            @object.Type = (UTinyType.Reference)m_TestStruct;

            // Dynamic values should be promoted to field values
            @object.Refresh();

            Assert.AreEqual("Test", @object["Foo"]);
            Assert.AreEqual(10, @object["Bar"]);

            Debug.Log(@object.ToString());
        }
        public void UTinyObject_Dynamic_ListPromotion()
        {
            // Untyped dynamic object
            var @object = new UTinyObject(m_Registry, UTinyType.Reference.None)
            {
                ["Foo"] = new UTinyList(m_Registry, UTinyType.Reference.None)
                {
                    "a", "b", "c"
                },
                ["Bar"] = new UTinyList(m_Registry, UTinyType.Reference.None)
                {
                    3, 6, 9
                }
            };

            @object.Type = (UTinyType.Reference)m_TestStructWithList;
            @object.Refresh();

            Debug.Log(@object.ToString());
        }
Beispiel #4
0
        private static void ParseUTinyList(IRegistry registry, UTinyList uTinyList, IDictionary <string, object> dictionary)
        {
            var typeReference = ParseTypeReference(GetValue(dictionary, "Type"), false);

            IList <object> itemsList;

            if (TryGetValue(dictionary, "Items", out itemsList))
            {
                foreach (var obj in itemsList)
                {
                    var valueDictionary = obj as IDictionary <string, object>;
                    if (valueDictionary != null)
                    {
                        if (valueDictionary.ContainsKey("$TypeId"))
                        {
                            uTinyList.Add(ParseCustomObjectType(registry, valueDictionary));
                        }
                        // @HACK We assume an object `Properties` OR `Type` keys is a `UTinyObject`
                        else if (valueDictionary.ContainsKey("Properties") || valueDictionary.ContainsKey("Type"))
                        {
                            var @object = new UTinyObject(registry, typeReference, null, false);
                            @object.Refresh(null, true);
                            ParseUTinyObject(registry, @object, valueDictionary);
                            uTinyList.Add(@object);
                        }
                        else
                        {
                            throw new NotImplementedException("CommandStream.FrontEnd Failed to deserialize UTinyList item");
                        }
                    }
                    else
                    {
                        uTinyList.Add(obj);
                    }
                }
            }

            uTinyList.Type = UTinyUpdater.UpdateReference(uTinyList.Type);
        }
        public void UTinyObject_Dynamic_NestedObjectPromotion()
        {
            // Untyped dynamic object
            var @object = new UTinyObject(m_Registry, UTinyType.Reference.None)
            {
                ["TestStructField"] = new UTinyObject(m_Registry, UTinyType.Reference.None)
                {
                    ["Dynamic"] = "Value",
                    ["Foo"]     = "Test",
                    // Bar should be auto generated in its default state
                },
                ["Baz"] = 1.3f
            };

            @object.Type = (UTinyType.Reference)m_TestComponent;
            @object.Refresh();

            // Assert.AreEqual("Value", (@object["TestStructField"] as UTinyObject)?["Dynamic"]);
            Assert.AreEqual("Test", (@object["TestStructField"] as UTinyObject)?["Foo"]);
            Assert.AreEqual(0, (@object["TestStructField"] as UTinyObject)?["Bar"]);
            // Assert.AreEqual(1.3F, @object["Baz"]);

            Debug.Log(@object.ToString());
        }
Beispiel #6
0
        private static void ParseUTinyObject(IRegistry registry, UTinyObject uTinyObject, IDictionary <string, object> dictionary)
        {
            IDictionary <string, object> propertiesDictionary;

            if (!TryGetValue(dictionary, "Properties", out propertiesDictionary))
            {
                UTinyUpdater.UpdateObject(uTinyObject);
                return;
            }

            var type = uTinyObject.Type.Dereference(registry);

            foreach (var kvp in propertiesDictionary)
            {
                var valueDictionary = kvp.Value as IDictionary <string, object>;

                if (valueDictionary != null)
                {
                    if (valueDictionary.ContainsKey("Properties"))
                    {
                        if (uTinyObject.HasProperty(kvp.Key))
                        {
                            ParseUTinyObject(registry, uTinyObject[kvp.Key] as UTinyObject, valueDictionary);
                        }
                        else
                        {
                            var typeReference = ParseTypeReference(GetValue(valueDictionary, "Type"), false);
                            var obj           = new UTinyObject(registry, typeReference, null, false);
                            obj.Refresh(null, true);
                            ParseUTinyObject(registry, obj, valueDictionary);
                            obj.Refresh(null, true);
                            uTinyObject[kvp.Key] = obj;
                        }
                    }
                    else if (valueDictionary.ContainsKey("Items"))
                    {
                        if (uTinyObject.HasProperty(kvp.Key))
                        {
                            ParseUTinyList(registry, uTinyObject[kvp.Key] as UTinyList, valueDictionary);
                        }
                        else
                        {
                            var obj = new UTinyList(registry, ParseTypeReference(GetValue(valueDictionary, "Type"), false));
                            ParseUTinyList(registry, obj, valueDictionary);
                            uTinyObject[kvp.Key] = obj;
                        }
                    }
                    else if (valueDictionary.ContainsKey("$TypeId"))
                    {
                        var value = ParseCustomObjectType(registry, valueDictionary);

                        var field = type?.FindFieldByName(kvp.Key);
                        if (field != null)
                        {
                            value = UTinyUpdater.UpdateField(field.Id, value);
                        }

                        uTinyObject[kvp.Key] = value;
                    }
                }
                else
                {
                    var value = kvp.Value;

                    var field = type?.FindFieldByName(kvp.Key);
                    if (field != null)
                    {
                        value = UTinyUpdater.UpdateField(field.Id, value);
                    }

                    uTinyObject[kvp.Key] = value;
                }
            }

            UTinyUpdater.UpdateObject(uTinyObject);
        }