コード例 #1
0
            public static Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component Deserialize(global::Improbable.Worker.Core.SchemaObject obj, global::Unity.Entities.World world)
            {
                var component = new Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component();

                {
                    component.BoolField = obj.GetBool(1);
                }
                {
                    component.IntField = obj.GetInt32(2);
                }
                {
                    component.LongField = obj.GetInt64(3);
                }
                {
                    component.FloatField = obj.GetFloat(4);
                }
                {
                    component.DoubleField = obj.GetDouble(5);
                }
                component.stringFieldHandle = Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.StringFieldProvider.Allocate(world);
                {
                    component.StringField = obj.GetString(6);
                }
                component.optionalFieldHandle = Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.OptionalFieldProvider.Allocate(world);
                {
                    if (obj.GetInt32Count(7) == 1)
                    {
                        component.OptionalField = new int?(obj.GetInt32(7));
                    }
                }
                component.listFieldHandle = Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.ListFieldProvider.Allocate(world);
                {
                    component.ListField = new global::System.Collections.Generic.List <int>();
                    var list       = component.ListField;
                    var listLength = obj.GetInt32Count(8);
                    for (var i = 0; i < listLength; i++)
                    {
                        list.Add(obj.IndexInt32(8, (uint)i));
                    }
                }
                component.mapFieldHandle = Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReferenceTypeProviders.MapFieldProvider.Allocate(world);
                {
                    component.MapField = new global::System.Collections.Generic.Dictionary <int, string>();
                    var map     = component.MapField;
                    var mapSize = obj.GetObjectCount(9);
                    for (var i = 0; i < mapSize; i++)
                    {
                        var mapObj = obj.IndexObject(9, (uint)i);
                        var key    = mapObj.GetInt32(1);
                        var value  = mapObj.GetString(2);
                        map.Add(key, value);
                    }
                }
                return(component);
            }
コード例 #2
0
            public static void ApplyUpdate(global::Improbable.Worker.Core.SchemaComponentUpdate updateObj, ref Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component component)
            {
                var obj = updateObj.GetFields();

                var clearedFields = updateObj.GetClearedFields();

                {
                    if (obj.GetBoolCount(1) == 1)
                    {
                        var value = obj.GetBool(1);
                        component.BoolField = value;
                    }
                }
                {
                    if (obj.GetInt32Count(2) == 1)
                    {
                        var value = obj.GetInt32(2);
                        component.IntField = value;
                    }
                }
                {
                    if (obj.GetInt64Count(3) == 1)
                    {
                        var value = obj.GetInt64(3);
                        component.LongField = value;
                    }
                }
                {
                    if (obj.GetFloatCount(4) == 1)
                    {
                        var value = obj.GetFloat(4);
                        component.FloatField = value;
                    }
                }
                {
                    if (obj.GetDoubleCount(5) == 1)
                    {
                        var value = obj.GetDouble(5);
                        component.DoubleField = value;
                    }
                }
                {
                    if (obj.GetStringCount(6) == 1)
                    {
                        var value = obj.GetString(6);
                        component.StringField = value;
                    }
                }
                {
                    bool isCleared = false;
                    foreach (var fieldIndex in clearedFields)
                    {
                        isCleared = fieldIndex == 7;
                        if (isCleared)
                        {
                            break;
                        }
                    }
                    if (isCleared)
                    {
                        component.OptionalField = new int?();
                    }
                    else if (obj.GetInt32Count(7) == 1)
                    {
                        var value = obj.GetInt32(7);
                        component.OptionalField = new int?(value);
                    }
                }
                {
                    var  listSize  = obj.GetInt32Count(8);
                    bool isCleared = false;
                    foreach (var fieldIndex in clearedFields)
                    {
                        isCleared = fieldIndex == 8;
                        if (isCleared)
                        {
                            break;
                        }
                    }
                    if (listSize > 0 || isCleared)
                    {
                        component.ListField.Clear();
                    }
                    for (var i = 0; i < listSize; i++)
                    {
                        var value = obj.IndexInt32(8, (uint)i);
                        component.ListField.Add(value);
                    }
                }
                {
                    var  mapSize   = obj.GetObjectCount(9);
                    bool isCleared = false;
                    foreach (var fieldIndex in clearedFields)
                    {
                        isCleared = fieldIndex == 9;
                        if (isCleared)
                        {
                            break;
                        }
                    }
                    if (mapSize > 0 || isCleared)
                    {
                        component.MapField.Clear();
                    }
                    for (var i = 0; i < mapSize; i++)
                    {
                        var mapObj = obj.IndexObject(9, (uint)i);
                        var key    = mapObj.GetInt32(1);
                        var value  = mapObj.GetString(2);
                        component.MapField.Add(key, value);
                    }
                }
            }
コード例 #3
0
            public static void SerializeUpdate(Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component component, global::Improbable.Worker.Core.SchemaComponentUpdate updateObj)
            {
                var obj = updateObj.GetFields();
                {
                    if (component.IsDataDirty(0))
                    {
                        obj.AddBool(1, component.BoolField);
                    }
                }
                {
                    if (component.IsDataDirty(1))
                    {
                        obj.AddInt32(2, component.IntField);
                    }
                }
                {
                    if (component.IsDataDirty(2))
                    {
                        obj.AddInt64(3, component.LongField);
                    }
                }
                {
                    if (component.IsDataDirty(3))
                    {
                        obj.AddFloat(4, component.FloatField);
                    }
                }
                {
                    if (component.IsDataDirty(4))
                    {
                        obj.AddDouble(5, component.DoubleField);
                    }
                }
                {
                    if (component.IsDataDirty(5))
                    {
                        obj.AddString(6, component.StringField);
                    }
                }
                {
                    if (component.IsDataDirty(6))
                    {
                        if (component.OptionalField.HasValue)
                        {
                            obj.AddInt32(7, component.OptionalField.Value);
                        }
                    }

                    if (!component.OptionalField.HasValue)
                    {
                        updateObj.AddClearedField(7);
                    }
                }
                {
                    if (component.IsDataDirty(7))
                    {
                        foreach (var value in component.ListField)
                        {
                            obj.AddInt32(8, value);
                        }
                    }

                    if (component.ListField.Count == 0)
                    {
                        updateObj.AddClearedField(8);
                    }
                }
                {
                    if (component.IsDataDirty(8))
                    {
                        foreach (var keyValuePair in component.MapField)
                        {
                            var mapObj = obj.AddObject(9);
                            mapObj.AddInt32(1, keyValuePair.Key);
                            mapObj.AddString(2, keyValuePair.Value);
                        }
                    }

                    if (component.MapField.Count == 0)
                    {
                        updateObj.AddClearedField(9);
                    }
                }
            }