public void OnAddComponent(AddComponentOp <global::Improbable.Gdk.Tests.NestedComponent> op)
            {
                Unity.Entities.Entity entity;
                if (!view.TryGetEntity(op.EntityId.Id, out entity))
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent("Entity not found during OnAddComponent.")
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField(MutableView.Component, "SpatialOSNestedComponent"));
                    return;
                }
                var data = op.Data.Get().Value;

                var spatialOSNestedComponent = new SpatialOSNestedComponent();

                spatialOSNestedComponent.NestedType = global::Generated.Improbable.Gdk.Tests.TypeName.ToNative(data.nestedType);
                spatialOSNestedComponent.DirtyBit   = false;

                view.AddComponent(entity, spatialOSNestedComponent);
                view.AddComponent(entity, new NotAuthoritative <SpatialOSNestedComponent>());

                if (view.HasComponent <ComponentRemoved <SpatialOSNestedComponent> >(entity))
                {
                    view.RemoveComponent <ComponentRemoved <SpatialOSNestedComponent> >(entity);
                }
                else if (!view.HasComponent <ComponentAdded <SpatialOSNestedComponent> >(entity))
                {
                    view.AddComponent(entity, new ComponentAdded <SpatialOSNestedComponent>());
                }
                else
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent(
                                                "Received ComponentAdded but have already received one for this entity.")
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField(MutableView.Component, "SpatialOSNestedComponent"));
                }
            }
            public override void OnRemoveComponent(RemoveComponentOp op)
            {
                var entity = TryGetEntityFromEntityId(op.EntityId);

                entityManager.RemoveComponent <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component>(entity);

                if (entityManager.HasComponent <ComponentAdded <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                {
                    entityManager.RemoveComponent <ComponentAdded <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity);
                }
                else if (!entityManager.HasComponent <ComponentRemoved <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                {
                    entityManager.AddComponent(entity, ComponentType.Create <ComponentRemoved <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >());
                }
                else
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent(ReceivedDuplicateComponentRemoved)
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField("Component", "Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents")
                                            );
                }
            }
            public override void OnAddComponent(AddComponentOp op)
            {
                var entity = TryGetEntityFromEntityId(op.EntityId);

                var data = Improbable.Gdk.Tests.ExhaustiveOptional.Serialization.Deserialize(op.Data.SchemaData.Value.GetFields(), World);

                data.DirtyBit = false;
                entityManager.AddComponentData(entity, data);
                entityManager.AddComponent(entity, ComponentType.Create <NotAuthoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >());

                var update = new Improbable.Gdk.Tests.ExhaustiveOptional.Update
                {
                    Field1  = data.Field1,
                    Field2  = data.Field2,
                    Field3  = data.Field3,
                    Field4  = data.Field4,
                    Field5  = data.Field5,
                    Field6  = data.Field6,
                    Field7  = data.Field7,
                    Field8  = data.Field8,
                    Field9  = data.Field9,
                    Field10 = data.Field10,
                    Field11 = data.Field11,
                    Field12 = data.Field12,
                    Field13 = data.Field13,
                    Field14 = data.Field14,
                    Field15 = data.Field15,
                    Field16 = data.Field16,
                    Field17 = data.Field17,
                };

                var updates = new List <Improbable.Gdk.Tests.ExhaustiveOptional.Update>
                {
                    update
                };

                var updatesComponent = new Improbable.Gdk.Tests.ExhaustiveOptional.ReceivedUpdates
                {
                    handle = ReferenceTypeProviders.UpdatesProvider.Allocate(World)
                };

                ReferenceTypeProviders.UpdatesProvider.Set(updatesComponent.handle, updates);
                entityManager.AddComponentData(entity, updatesComponent);

                if (entityManager.HasComponent <ComponentRemoved <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                {
                    entityManager.RemoveComponent <ComponentRemoved <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity);
                }
                else if (!entityManager.HasComponent <ComponentAdded <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                {
                    entityManager.AddComponent(entity, ComponentType.Create <ComponentAdded <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >());
                }
                else
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent(ReceivedDuplicateComponentAdded)
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField("Component", "Improbable.Gdk.Tests.ExhaustiveOptional")
                                            );
                }
            }
            public void OnComponentUpdate(ComponentUpdateOp <global::Improbable.Gdk.Tests.ExhaustiveOptional> op)
            {
                Unity.Entities.Entity entity;
                if (!view.TryGetEntity(op.EntityId.Id, out entity))
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent("Entity not found during OnComponentUpdate.")
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField(MutableView.Component, "SpatialOSExhaustiveOptional"));
                    return;
                }

                var componentData = view.GetComponentObject <SpatialOSExhaustiveOptional>(entity);
                var update        = op.Update.Get();

                if (view.HasComponent <NotAuthoritative <SpatialOSExhaustiveOptional> >(entity))
                {
                    if (update.field2.HasValue)
                    {
                        componentData.Field2 = update.field2.Value.HasValue ? new global::System.Nullable <float>(update.field2.Value.Value) : new global::System.Nullable <float>();
                    }
                    if (update.field4.HasValue)
                    {
                        componentData.Field4 = update.field4.Value.HasValue ? new global::System.Nullable <int>(update.field4.Value.Value) : new global::System.Nullable <int>();
                    }
                    if (update.field5.HasValue)
                    {
                        componentData.Field5 = update.field5.Value.HasValue ? new global::System.Nullable <long>(update.field5.Value.Value) : new global::System.Nullable <long>();
                    }
                    if (update.field6.HasValue)
                    {
                        componentData.Field6 = update.field6.Value.HasValue ? new global::System.Nullable <double>(update.field6.Value.Value) : new global::System.Nullable <double>();
                    }
                    if (update.field8.HasValue)
                    {
                        componentData.Field8 = update.field8.Value.HasValue ? new global::System.Nullable <uint>(update.field8.Value.Value) : new global::System.Nullable <uint>();
                    }
                    if (update.field9.HasValue)
                    {
                        componentData.Field9 = update.field9.Value.HasValue ? new global::System.Nullable <ulong>(update.field9.Value.Value) : new global::System.Nullable <ulong>();
                    }
                    if (update.field10.HasValue)
                    {
                        componentData.Field10 = update.field10.Value.HasValue ? new global::System.Nullable <int>(update.field10.Value.Value) : new global::System.Nullable <int>();
                    }
                    if (update.field11.HasValue)
                    {
                        componentData.Field11 = update.field11.Value.HasValue ? new global::System.Nullable <long>(update.field11.Value.Value) : new global::System.Nullable <long>();
                    }
                    if (update.field12.HasValue)
                    {
                        componentData.Field12 = update.field12.Value.HasValue ? new global::System.Nullable <uint>(update.field12.Value.Value) : new global::System.Nullable <uint>();
                    }
                    if (update.field13.HasValue)
                    {
                        componentData.Field13 = update.field13.Value.HasValue ? new global::System.Nullable <ulong>(update.field13.Value.Value) : new global::System.Nullable <ulong>();
                    }
                    if (update.field14.HasValue)
                    {
                        componentData.Field14 = update.field14.Value.HasValue ? new global::System.Nullable <int>(update.field14.Value.Value) : new global::System.Nullable <int>();
                    }
                    if (update.field15.HasValue)
                    {
                        componentData.Field15 = update.field15.Value.HasValue ? new global::System.Nullable <long>(update.field15.Value.Value) : new global::System.Nullable <long>();
                    }
                    if (update.field16.HasValue)
                    {
                        componentData.Field16 = update.field16.Value.HasValue ? new global::System.Nullable <long>(update.field16.Value.Value.Id) : new global::System.Nullable <long>();
                    }
                    if (update.field17.HasValue)
                    {
                        componentData.Field17 = update.field17.Value.HasValue ? new global::System.Nullable <global::Generated.Improbable.Gdk.Tests.SomeType>(global::Generated.Improbable.Gdk.Tests.SomeType.ToNative(update.field17.Value.Value)) : new global::System.Nullable <global::Generated.Improbable.Gdk.Tests.SomeType>();
                    }
                }

                componentData.DirtyBit = false;

                view.SetComponentObject(entity, componentData);

                var componentFieldsUpdated = false;
                var gdkUpdate = new SpatialOSExhaustiveOptional.Update();

                if (update.field2.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field2       = new Option <global::System.Nullable <float> >(update.field2.Value.HasValue ? new global::System.Nullable <float>(update.field2.Value.Value) : new global::System.Nullable <float>());
                }
                if (update.field4.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field4       = new Option <global::System.Nullable <int> >(update.field4.Value.HasValue ? new global::System.Nullable <int>(update.field4.Value.Value) : new global::System.Nullable <int>());
                }
                if (update.field5.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field5       = new Option <global::System.Nullable <long> >(update.field5.Value.HasValue ? new global::System.Nullable <long>(update.field5.Value.Value) : new global::System.Nullable <long>());
                }
                if (update.field6.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field6       = new Option <global::System.Nullable <double> >(update.field6.Value.HasValue ? new global::System.Nullable <double>(update.field6.Value.Value) : new global::System.Nullable <double>());
                }
                if (update.field8.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field8       = new Option <global::System.Nullable <uint> >(update.field8.Value.HasValue ? new global::System.Nullable <uint>(update.field8.Value.Value) : new global::System.Nullable <uint>());
                }
                if (update.field9.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field9       = new Option <global::System.Nullable <ulong> >(update.field9.Value.HasValue ? new global::System.Nullable <ulong>(update.field9.Value.Value) : new global::System.Nullable <ulong>());
                }
                if (update.field10.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field10      = new Option <global::System.Nullable <int> >(update.field10.Value.HasValue ? new global::System.Nullable <int>(update.field10.Value.Value) : new global::System.Nullable <int>());
                }
                if (update.field11.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field11      = new Option <global::System.Nullable <long> >(update.field11.Value.HasValue ? new global::System.Nullable <long>(update.field11.Value.Value) : new global::System.Nullable <long>());
                }
                if (update.field12.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field12      = new Option <global::System.Nullable <uint> >(update.field12.Value.HasValue ? new global::System.Nullable <uint>(update.field12.Value.Value) : new global::System.Nullable <uint>());
                }
                if (update.field13.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field13      = new Option <global::System.Nullable <ulong> >(update.field13.Value.HasValue ? new global::System.Nullable <ulong>(update.field13.Value.Value) : new global::System.Nullable <ulong>());
                }
                if (update.field14.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field14      = new Option <global::System.Nullable <int> >(update.field14.Value.HasValue ? new global::System.Nullable <int>(update.field14.Value.Value) : new global::System.Nullable <int>());
                }
                if (update.field15.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field15      = new Option <global::System.Nullable <long> >(update.field15.Value.HasValue ? new global::System.Nullable <long>(update.field15.Value.Value) : new global::System.Nullable <long>());
                }
                if (update.field16.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field16      = new Option <global::System.Nullable <long> >(update.field16.Value.HasValue ? new global::System.Nullable <long>(update.field16.Value.Value.Id) : new global::System.Nullable <long>());
                }
                if (update.field17.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.Field17      = new Option <global::System.Nullable <global::Generated.Improbable.Gdk.Tests.SomeType> >(update.field17.Value.HasValue ? new global::System.Nullable <global::Generated.Improbable.Gdk.Tests.SomeType>(global::Generated.Improbable.Gdk.Tests.SomeType.ToNative(update.field17.Value.Value)) : new global::System.Nullable <global::Generated.Improbable.Gdk.Tests.SomeType>());
                }

                if (componentFieldsUpdated)
                {
                    view.AddComponentsUpdated(entity, gdkUpdate, UpdatesPool);
                }
            }
            public override void OnAddComponent(AddComponentOp op)
            {
                if (!IsValidEntityId(op.EntityId, "AddComponentOp", out var entity))
                {
                    return;
                }

                var data = Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Serialization.Deserialize(op.Data.SchemaData.Value.GetFields(), World);

                data.DirtyBit = false;
                entityManager.AddComponentData(entity, data);
                entityManager.AddComponentData(entity, new NotAuthoritative <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component>());

                var update = new Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Update
                {
                    Field1  = data.Field1,
                    Field2  = data.Field2,
                    Field4  = data.Field4,
                    Field5  = data.Field5,
                    Field6  = data.Field6,
                    Field8  = data.Field8,
                    Field9  = data.Field9,
                    Field10 = data.Field10,
                    Field11 = data.Field11,
                    Field12 = data.Field12,
                    Field13 = data.Field13,
                    Field14 = data.Field14,
                    Field15 = data.Field15,
                    Field16 = data.Field16,
                    Field17 = data.Field17,
                };

                var updates = new List <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Update>
                {
                    update
                };

                var updatesComponent = new Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.ReceivedUpdates
                {
                    handle = ReferenceTypeProviders.UpdatesProvider.Allocate(World)
                };

                ReferenceTypeProviders.UpdatesProvider.Set(updatesComponent.handle, updates);
                entityManager.AddComponentData(entity, updatesComponent);

                if (entityManager.HasComponent <ComponentRemoved <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component> >(entity))
                {
                    entityManager.RemoveComponent <ComponentRemoved <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component> >(entity);
                }
                else if (!entityManager.HasComponent <ComponentAdded <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component> >(entity))
                {
                    entityManager.AddComponentData(entity, new ComponentAdded <Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular.Component>());
                }
                else
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent(ReceivedDuplicateComponentAdded)
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField("Component", "Generated.Improbable.Gdk.Tests.ExhaustiveBlittableSingular")
                                            );
                }
            }
            public void OnComponentUpdate(ComponentUpdateOp <global::Improbable.Gdk.Tests.BlittableTypes.BlittableComponent> op)
            {
                Unity.Entities.Entity entity;
                if (!view.TryGetEntity(op.EntityId.Id, out entity))
                {
                    LogDispatcher.HandleLog(LogType.Error, new LogEvent("Entity not found during OnComponentUpdate.")
                                            .WithField(LoggingUtils.LoggerName, LoggerName)
                                            .WithField(LoggingUtils.EntityId, op.EntityId.Id)
                                            .WithField(MutableView.Component, "SpatialOSBlittableComponent"));
                    return;
                }

                var componentData = view.GetComponent <SpatialOSBlittableComponent>(entity);
                var update        = op.Update.Get();

                if (view.HasComponent <NotAuthoritative <SpatialOSBlittableComponent> >(entity))
                {
                    if (update.boolField.HasValue)
                    {
                        componentData.BoolField = update.boolField.Value;
                    }
                    if (update.intField.HasValue)
                    {
                        componentData.IntField = update.intField.Value;
                    }
                    if (update.longField.HasValue)
                    {
                        componentData.LongField = update.longField.Value;
                    }
                    if (update.floatField.HasValue)
                    {
                        componentData.FloatField = update.floatField.Value;
                    }
                    if (update.doubleField.HasValue)
                    {
                        componentData.DoubleField = update.doubleField.Value;
                    }
                }

                var firstEventEvents = update.firstEvent;

                foreach (var spatialEvent in firstEventEvents)
                {
                    var nativeEvent = new FirstEventEvent
                    {
                        Payload = global::Generated.Improbable.Gdk.Tests.BlittableTypes.FirstEventPayload.ToNative(spatialEvent)
                    };

                    view.AddEventReceived(entity, nativeEvent, FirstEventEventPool);
                }
                var secondEventEvents = update.secondEvent;

                foreach (var spatialEvent in secondEventEvents)
                {
                    var nativeEvent = new SecondEventEvent
                    {
                        Payload = global::Generated.Improbable.Gdk.Tests.BlittableTypes.SecondEventPayload.ToNative(spatialEvent)
                    };

                    view.AddEventReceived(entity, nativeEvent, SecondEventEventPool);
                }
                componentData.DirtyBit = false;

                view.SetComponentData(entity, componentData);

                var componentFieldsUpdated = false;
                var gdkUpdate = new SpatialOSBlittableComponent.Update();

                if (update.boolField.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.BoolField    = new Option <BlittableBool>(update.boolField.Value);
                }
                if (update.intField.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.IntField     = new Option <int>(update.intField.Value);
                }
                if (update.longField.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.LongField    = new Option <long>(update.longField.Value);
                }
                if (update.floatField.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.FloatField   = new Option <float>(update.floatField.Value);
                }
                if (update.doubleField.HasValue)
                {
                    componentFieldsUpdated = true;
                    gdkUpdate.DoubleField  = new Option <double>(update.doubleField.Value);
                }

                if (componentFieldsUpdated)
                {
                    view.AddComponentsUpdated(entity, gdkUpdate, UpdatesPool);
                }
            }