Exemplo n.º 1
0
 public static void SerializeSnapshot(global::Improbable.DependentSchema.DependentComponent.Snapshot snapshot, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         global::Improbable.TestSchema.ExhaustiveRepeatedData.Serialization.Serialize(snapshot.A, obj.AddObject(1));
     }
     {
         obj.AddEnum(2, (uint)snapshot.B);
     }
     {
         if (snapshot.C.HasValue)
         {
             obj.AddEnum(3, (uint)snapshot.C.Value);
         }
     }
     {
         foreach (var value in snapshot.D)
         {
             global::Improbable.TestSchema.SomeType.Serialization.Serialize(value, obj.AddObject(4));
         }
     }
     {
         foreach (var keyValuePair in snapshot.E)
         {
             var mapObj = obj.AddObject(5);
             mapObj.AddEnum(1, (uint)keyValuePair.Key);
             global::Improbable.TestSchema.SomeType.Serialization.Serialize(keyValuePair.Value, mapObj.AddObject(2));
         }
     }
 }
Exemplo n.º 2
0
            public static global::Improbable.DependentSchema.DependentComponent.Snapshot DeserializeSnapshot(global::Improbable.Worker.CInterop.SchemaObject obj)
            {
                var component = new global::Improbable.DependentSchema.DependentComponent.Snapshot();

                {
                    component.A = global::Improbable.TestSchema.ExhaustiveRepeatedData.Serialization.Deserialize(obj.GetObject(1));
                }

                {
                    component.B = (global::Improbable.TestSchema.SomeEnum)obj.GetEnum(2);
                }

                {
                    if (obj.GetEnumCount(3) == 1)
                    {
                        component.C = new global::Improbable.TestSchema.SomeEnum?((global::Improbable.TestSchema.SomeEnum)obj.GetEnum(3));
                    }
                }

                {
                    component.D = new global::System.Collections.Generic.List <global::Improbable.TestSchema.SomeType>();
                    var list       = component.D;
                    var listLength = obj.GetObjectCount(4);
                    for (var i = 0; i < listLength; i++)
                    {
                        list.Add(global::Improbable.TestSchema.SomeType.Serialization.Deserialize(obj.IndexObject(4, (uint)i)));
                    }
                }

                {
                    component.E = new global::System.Collections.Generic.Dictionary <global::Improbable.TestSchema.SomeEnum, global::Improbable.TestSchema.SomeType>();
                    var map     = component.E;
                    var mapSize = obj.GetObjectCount(5);
                    for (var i = 0; i < mapSize; i++)
                    {
                        var mapObj = obj.IndexObject(5, (uint)i);
                        var key    = (global::Improbable.TestSchema.SomeEnum)mapObj.GetEnum(1);
                        var value  = global::Improbable.TestSchema.SomeType.Serialization.Deserialize(mapObj.GetObject(2));
                        map.Add(key, value);
                    }
                }

                return(component);
            }
            public static void ApplyUpdate(global::Improbable.Worker.CInterop.SchemaComponentUpdate updateObj, ref global::Improbable.DependentSchema.DependentComponent.Snapshot snapshot)
            {
                var obj = updateObj.GetFields();

                if (obj.GetObjectCount(1) == 1)
                {
                    snapshot.A = global::Improbable.TestSchema.ExhaustiveRepeatedData.Serialization.Deserialize(obj.GetObject(1));
                }

                if (obj.GetEnumCount(2) == 1)
                {
                    snapshot.B = (global::Improbable.TestSchema.SomeEnum)obj.GetEnum(2);
                }

                {
                    var isCleared = updateObj.IsFieldCleared(3);

                    if (isCleared)
                    {
                        snapshot.C = new global::Improbable.TestSchema.SomeEnum?();
                    }
                    else if (obj.GetEnumCount(3) == 1)
                    {
                        var value = (global::Improbable.TestSchema.SomeEnum)obj.GetEnum(3);
                        snapshot.C = new global::Improbable.TestSchema.SomeEnum?(value);
                    }
                }

                {
                    var listSize = obj.GetObjectCount(4);

                    var isCleared = updateObj.IsFieldCleared(4);

                    if (listSize > 0 || isCleared)
                    {
                        snapshot.D.Clear();
                    }

                    for (var i = 0; i < listSize; i++)
                    {
                        var value = global::Improbable.TestSchema.SomeType.Serialization.Deserialize(obj.IndexObject(4, (uint)i));
                        snapshot.D.Add(value);
                    }
                }

                {
                    var mapSize = obj.GetObjectCount(5);

                    var isCleared = updateObj.IsFieldCleared(5);

                    if (mapSize > 0 || isCleared)
                    {
                        snapshot.E.Clear();
                    }

                    for (var i = 0; i < mapSize; i++)
                    {
                        var mapObj = obj.IndexObject(5, (uint)i);
                        var key    = (global::Improbable.TestSchema.SomeEnum)mapObj.GetEnum(1);
                        var value  = global::Improbable.TestSchema.SomeType.Serialization.Deserialize(mapObj.GetObject(2));
                        snapshot.E.Add(key, value);
                    }
                }
            }