private void FacadeTest <TUnderlyingType, TType, TConverter>( TUnderlyingType underlyingValue, TType value, TypeModelContainer container = null) where TConverter : struct, ITypeFacadeConverter <TUnderlyingType, TType> { if (container == null) { container = TypeModelContainer.CreateDefault(); container.RegisterTypeFacade <TUnderlyingType, TType, TConverter>(); } FlatBufferSerializer serializer = new FlatBufferSerializer( new FlatBufferSerializerOptions(FlatBufferDeserializationOption.Greedy), container); byte[] destination = new byte[1024]; byte[] destination2 = new byte[1024]; var compiled = serializer.Compile <ExtensionTable <TType> >(); var underlyingItem = new ExtensionTable <TUnderlyingType> { Item = underlyingValue }; var facadeItem = new ExtensionTable <TType> { Item = value }; serializer.Serialize(facadeItem, destination); serializer.Serialize(underlyingItem, destination2); Assert.True(destination.AsSpan().SequenceEqual(destination2)); var parsed = serializer.Parse <ExtensionTable <TType> >(destination); Assert.Equal(parsed.Item, value); Assert.Equal(serializer.GetMaxSize(facadeItem), serializer.GetMaxSize(underlyingItem)); }
public void LazyMemoryCopySerialization() { TestTable <WriteThroughStruct> t = new() { Foo = "foobar", Struct = new WriteThroughStruct { Bar = 12, } }; FlatBufferSerializer serializer = new FlatBufferSerializer(FlatBufferDeserializationOption.Lazy); var compiled = serializer.Compile <TestTable <WriteThroughStruct> >().WithSettings(new SerializerSettings { EnableMemoryCopySerialization = true }); byte[] data = new byte[1024]; Assert.Equal(70, compiled.GetMaxSize(t)); int actualBytes = compiled.Write(data, t); // First test: Parse the array but don't trim the buffer. This causes the underlying // buffer to be much larger than the actual data. var parsed = compiled.Parse(data); byte[] data2 = new byte[2048]; int bytesWritten = compiled.Write(data2, parsed); Assert.Equal(35, actualBytes); Assert.Equal(1024, bytesWritten); // We use mem copy serialization here, and we gave it 1024 bytes when we parsed. So we get 1024 bytes back out. Assert.Equal(1024, compiled.GetMaxSize(parsed)); Assert.Throws <BufferTooSmallException>(() => compiled.Write(new byte[35], parsed)); // Repeat, but now using the trimmed array. parsed = compiled.Parse(data.AsMemory().Slice(0, actualBytes)); bytesWritten = compiled.Write(data2, parsed); Assert.Equal(35, actualBytes); Assert.Equal(35, bytesWritten); Assert.Equal(35, compiled.GetMaxSize(parsed)); // Default still returns 70. Assert.Equal(70, serializer.GetMaxSize(parsed)); }
public static void SaveGame(String pathToFolder, NamelessGame game) { var saveFile = new NamelessRogueSaveFile(); Type iStorageInterfaceType = typeof(IStorage <>); foreach (var componentTypeCollection in EntityInfrastructureManager.Components) { if (componentTypeCollection.Key.GetCustomAttributes(true).Any(a => a.GetType() == typeof(NamelessRogue.Engine.Serialization.SkipClassGeneration))) { continue; } foreach (var componentDictionary in componentTypeCollection.Value) { //the type of the storage that can store current type Type storageType = saveFile.ComponentTypeToStorge[componentTypeCollection.Key]; var constructor = storageType.GetConstructor(Type.EmptyTypes); if (constructor == null) { throw new Exception($@"{storageType.Name} must contain a parameterless constructor in order for Save manager to serialize it"); } dynamic storageObject = constructor.Invoke(null); storageObject.FillFrom(ObjectExtensions.CastToReflected(componentDictionary.Value, componentDictionary.Value.GetType())); saveFile.StoragesDictionary[storageObject.GetType()].Add(storageObject); } } foreach (var entity in EntityInfrastructureManager.Entities.Values) { var storage = new EntityStorage(); storage.FillFrom(entity); saveFile.EntityStorageTable.Add(storage); } { int maxBytesNeeded = FlatBufferSerializer.Default.GetMaxSize(saveFile); byte[] buffer = new byte[maxBytesNeeded]; int bytesWritten = FlatBufferSerializer.Default.Serialize(saveFile, buffer); var stream = File.OpenWrite("objectdata.nrs"); stream.Write(buffer, 0, bytesWritten); stream.Close(); } { TimelineStorage timelinesStorage = new TimelineStorage(); var timeline = game.TimelineEntity.GetComponentOfType <TimeLine>(); timelinesStorage.FillFrom(timeline); { FlatBufferSerializer serializer = new FlatBufferSerializer(FlatBufferDeserializationOption.Greedy); int maxBytesNeeded = serializer.GetMaxSize(timelinesStorage); int byteNeeded = serializer.GetMaxSize(timelinesStorage.CurrentTimelineLayer.WorldTiles[50 * 10]); byte[] buffer = new byte[maxBytesNeeded]; int bytesWritten = serializer.Serialize(timelinesStorage, buffer); var stream = File.OpenWrite("chunksmemory.nrs"); stream.Write(buffer, 0, bytesWritten); stream.Close(); } } }