private BlueprintManager LoadBlueprints() { var blueprintManager = new BlueprintManager(); XmlSerializer blueprintManagerSerializer = null; Object[] blueprintAssets = Resources.LoadAll(this.BlueprintAssetsFolder); foreach (var blueprintObjectAsset in blueprintAssets) { var blueprintAsset = blueprintObjectAsset as TextAsset; if (blueprintAsset != null) { var blueprintStream = new MemoryStream(blueprintAsset.bytes); // Load blueprints. BlueprintManager subBlueprintManager = null; if (Application.isEditor || this.UseXmlInBuild) { if (blueprintManagerSerializer == null) { blueprintManagerSerializer = new XmlSerializer(typeof(BlueprintManager)); } try { subBlueprintManager = (BlueprintManager)blueprintManagerSerializer.Deserialize(blueprintStream); } catch (XmlException e) { Debug.LogError( string.Format( "Exception deserializing blueprint xml '{0}': {1}", blueprintAsset.name, e.Message)); } } else { BinaryDeserializer binaryDeserializer = new BinaryDeserializer(blueprintStream); subBlueprintManager = binaryDeserializer.Deserialize <BlueprintManager>(); } if (subBlueprintManager != null) { blueprintManager.AddBlueprints(subBlueprintManager); } } else { Debug.LogError(string.Format("Blueprint asset is no text asset: {0}", blueprintObjectAsset.name)); } } // Resolve parents. BlueprintUtils.ResolveParents(blueprintManager, blueprintManager); return(blueprintManager); }
public static void SetVector(BinaryDeserializer Deserializer, GfxFloatKeyFrameGroup[] Vector) { long Position = Deserializer.BaseStream.Position; uint Flags = GetFlagsFromElem(Deserializer, Position); uint ConstantMask = 1u; uint NotExistMask = 1u << Vector.Length; for (int Axis = 0; Axis < Vector.Length; Axis++) { Deserializer.BaseStream.Seek(Position, SeekOrigin.Begin); Position += 4; bool Constant = (Flags & ConstantMask) != 0; bool Exists = (Flags & NotExistMask) == 0; if (Exists) { Vector[Axis] = GfxFloatKeyFrameGroup.ReadGroup(Deserializer, Constant); } ConstantMask <<= 1; NotExistMask <<= 1; } }
/// <summary> /// Encodes a BLOB reference. /// </summary> /// <param name="BlobReference">Binary BLOB reference.</param> /// <param name="BlobData">Original BLOB data.</param> /// <returns>Encoded BLOB reference.</returns> public byte[] EncodeBlobReference(byte[] BlobReference, byte[] BlobData) { BinaryDeserializer Reader = new BinaryDeserializer(this.collectionName, this.encoding, BlobReference, int.MaxValue); if (!Reader.ReadBit()) { return(BlobReference); } string Key = Reader.ReadString(); int KeyPos = Reader.Position; int c = BlobData.Length; int FullPayloadLen = c - KeyPos; BinarySerializer Writer = new BinarySerializer(this.collectionName, this.encoding); Writer.WriteBit(true); Writer.Write(Key); Writer.WriteBits(ObjectSerializer.TYPE_MAX, 6); Writer.WriteVariableLengthUInt64((uint)FullPayloadLen); Writer.WriteRaw(BlobReference, BlobReference.Length - 4, 4); return(Writer.GetSerialization()); }
public static H3D Open(MemoryStream MS) { //Please note that data should be on Memory when opening because addresses are relocated. //Otherwise the original file would be corrupted! BinaryDeserializer Deserializer = new BinaryDeserializer(MS, GetSerializationOptions()); H3DHeader Header = Deserializer.Deserialize <H3DHeader>(); new H3DRelocator(MS, Header).ToAbsolute(); H3D Scene = Deserializer.Deserialize <H3D>(); Scene.BackwardCompatibility = Header.BackwardCompatibility; Scene.ForwardCompatibility = Header.ForwardCompatibility; Scene.ConverterVersion = Header.ConverterVersion; Scene.Flags = Header.Flags; /*Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(Scene, Newtonsoft.Json.Formatting.Indented, new Newtonsoft.Json.JsonSerializerSettings() * { * ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore * }));*/ Scene.SourceData.Add(Scene); return(Scene); }
public void SimpleParentUserTestDeserializeBase(byte[] Result, SimpleParentUserInfo Value, BaseOptionInfo SerializerOptions) { //in this example server side has SimpleUserInfo //server side has Id, Name, Family //and the client side has SimpleUserOldStructureInfo //client side has Id, Age, BirthDate ,Name //new structure of models var newStructureModels = BinarySerializer.GetStructureModels(SerializerOptions); //my old deserializer var myDeserializer = new BinaryDeserializer(); myDeserializer.Options = new BinaryGo.Helpers.BaseOptionInfo(); #region VersionChangedControl //generate type myDeserializer.Options.GenerateType <SimpleParentUserOldStructureInfo>(); //add model renamed myDeserializer.AddMovedType(myDeserializer.GetStrcutureModelName(typeof(SimpleParentUserInfo)), typeof(SimpleParentUserOldStructureInfo)); //build new structure to old structure myDeserializer.BuildStructure(newStructureModels); #endregion var result = myDeserializer.Deserialize <SimpleParentUserOldStructureInfo>(Result); Assert.True(result.IsEquals(Value)); //now serialize from client side and deserialize from server side happen result.Passport = "AV12345678"; BinarySerializer binarySerializer = new BinarySerializer(myDeserializer.Options); var resultSerialized = binarySerializer.Serialize(result); var resultDeserialized = myDeserializer.Deserialize <SimpleParentUserOldStructureInfo>(resultSerialized); Assert.True(resultDeserialized.IsEquals(Value)); }
public BlockHeader(BinaryDeserializer Reader) { this.BytesUsed = Reader.ReadUInt16(); // 0: Counts number of bytes used in block, excluding the node header, and the last block link (14 bytes in total). this.SizeSubtree = Reader.ReadUInt32(); // 2: Order statistic tree, counting number of objects rooted at the current node. this.LastBlockIndex = Reader.ReadBlockLink(); // 6: Last block link. this.ParentBlockIndex = Reader.ReadBlockLink(); // 10: Parent block link. }
public static void SkipHeader(BinaryDeserializer Reader) { Reader.SkipUInt16(); Reader.SkipUInt32(); Reader.SkipUInt32(); Reader.SkipUInt32(); }
private static object Make_YuzuTest__SampleMergeNonPrimitive(BinaryDeserializer d, ReaderClassDef def) { var result = new global::YuzuTest.SampleMergeNonPrimitive(); Read_YuzuTest__SampleMergeNonPrimitive(d, def, result); return(result); }
public async Task GetIndexConfirmed_BinaryValueFound_ReturnsValue() { var input = UInt160.Parse(RandomInt().ToString("X40")); var expectedBytes = new byte[1]; var expectedSet = new HashSet <CoinReference> { new CoinReference { PrevHash = UInt256.Parse(RandomInt().ToString("X64")), PrevIndex = 0 }, new CoinReference { PrevHash = UInt256.Parse(RandomInt().ToString("X64")), PrevIndex = 0 } }; var contextMock = AutoMockContainer.GetMock <IRedisDbContext>(); contextMock.Setup(m => m.Get(input.BuildIxConfirmedKey())).ReturnsAsync(expectedBytes); var deserializerMock = AutoMockContainer.GetMock <IBinaryDeserializer>(); deserializerMock.Setup(m => m.Deserialize <HashSet <CoinReference> >(expectedBytes, null)) .Returns(expectedSet); var testee = AutoMockContainer.Create <RedisDbBinaryRepository>(); BinaryDeserializer.Initialize(deserializerMock.Object); var result = await testee.GetIndexConfirmed(input); result.SetEquals(expectedSet).Should().BeTrue(); }
/// <summary> /// Reads this object from its binary representation. /// </summary> /// <param name="deserializer">Deserializer to read the object with.</param> public void Deserialize(BinaryDeserializer deserializer) { this.AdditionalComponentTypes = deserializer.Deserialize <string[]>().Select <string, Type>(ReflectionUtils.FindType).ToList(); this.BlueprintId = deserializer.Deserialize <string>(); this.Configuration = deserializer.Deserialize <AttributeTable>(); }
public void TestSimpleObject() { var serializer = new BinarySerializer(); var obj = Create(); serializer.PrepareObjectGraph(obj); var result = serializer.SerializeObjectGraph(); var deserializer = new BinaryDeserializer(); var deserObj = (BasicObject)deserializer.DeserializeObjectGraph(result); Assert.Equal(obj.TestIntZero, deserObj.TestIntZero); Assert.Equal(obj.TestStringContent, deserObj.TestStringContent); Assert.Equal(obj.TestStringNull, deserObj.TestStringNull); Assert.Equal(obj.TestIntMax, deserObj.TestIntMax); Assert.Equal(obj.TestIntMin, deserObj.TestIntMin); Assert.Equal(obj.TestDoubleMax, deserObj.TestDoubleMax); Assert.Equal(obj.TestDoubleMin, deserObj.TestDoubleMin); Assert.Equal(obj.TestDoubleNan, deserObj.TestDoubleNan); Assert.Equal(obj.TestDoubleZero, deserObj.TestDoubleZero); Assert.Equal(obj.TestBoolFalse, deserObj.TestBoolFalse); Assert.Equal(obj.TestBoolTrue, deserObj.TestBoolTrue); Assert.Equal(obj.TestLongMin, deserObj.TestLongMin); Assert.Equal(obj.TestLongMax, deserObj.TestLongMax); Assert.Equal(obj.TestULongMax, deserObj.TestULongMax); Assert.Equal(obj.TestUShortMin, deserObj.TestUShortMin); Assert.Equal(obj.TestShortMin, deserObj.TestShortMin); Assert.Equal(obj.TestFloatMax, deserObj.TestFloatMax); Assert.Equal(obj.TestDateTime, deserObj.TestDateTime); Assert.Equal(0, deserObj.TestSkipInt); }
private static void InitializeBinarySerializer( IBinarySerializer binarySerializer, IBinaryDeserializer binaryDeserializer) { BinarySerializer.Initialize(binarySerializer); BinaryDeserializer.Initialize(binaryDeserializer); }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBits(6); } switch (DataType.Value) { case ObjectSerializer.TYPE_DATETIME: return((DateTimeOffset)Reader.ReadDateTime()); case ObjectSerializer.TYPE_DATETIMEOFFSET: return(Reader.ReadDateTimeOffset()); case ObjectSerializer.TYPE_STRING: case ObjectSerializer.TYPE_CI_STRING: return(DateTimeOffset.Parse(Reader.ReadString())); case ObjectSerializer.TYPE_MIN: return(DateTimeOffset.MinValue); case ObjectSerializer.TYPE_MAX: return(DateTimeOffset.MaxValue); case ObjectSerializer.TYPE_NULL: return(null); default: throw new Exception("Expected a DateTimeOffset value."); } }
public void RiskyFlySerialization() { var origin = new DateTime(2017, 02, 07); var atms = new double[] { 0.3, 0.32, 0.34 }; var fwds = new double[] { 100, 102, 110 }; var maturities = new DateTime[] { new DateTime(2017, 04, 06), new DateTime(2017, 06, 07), new DateTime(2017, 08, 07) }; var wingDeltas = new[] { 0.1, 0.25 }; var riskies = new[] { new[] { 0.025, 0.015 }, new[] { 0.025, 0.015 }, new[] { 0.025, 0.015 } }; var flies = new[] { new[] { 0.0025, 0.0015 }, new[] { 0.0025, 0.0015 }, new[] { 0.0025, 0.0015 } }; var surface = new RiskyFlySurface( origin, atms, maturities, wingDeltas, riskies, flies, fwds, WingQuoteType.Simple, AtmVolType.ZeroDeltaStraddle, Interpolator1DType.Linear, Interpolator1DType.LinearInVariance); Assert.Equal(atms[1], surface.GetVolForDeltaStrike(0.5, maturities[1], fwds[1])); var binSer = new BinarySerializer(); binSer.PrepareObjectGraph(surface); var span = binSer.SerializeObjectGraph(); var binDeser = new BinaryDeserializer(); var surface2 = (ObjectWithLists)binDeser.DeserializeObjectGraph(span); Assert.Equal(atms[1], surface.GetVolForDeltaStrike(0.5, maturities[1], fwds[1])); }
private void LoadSettings(object sender, EventArgs e) { var ofd = new OpenFileDialog { DefaultExt = ".tgc", Filter = "Файлы настроек (*.tgc)|*.tgc|Все файлы (*.*)|*.*" }; if (ofd.ShowDialog() != DialogResult.OK) { return; } var s = new BinaryDeserializer(ofd.FileName); if (!s.Open()) { MessageBox.Show("Не удалось открыть файл"); return; } if (!_scene.Settings.Serialize(s)) { MessageBox.Show("Не удалось загрузить настройки"); s.Close(); return; } s.Close(); RefreshSettings(); }
void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer) { PICACommandReader Reader = new PICACommandReader(Commands); while (Reader.HasCommand) { PICACommand Cmd = Reader.GetCommand(); uint Param = Cmd.Parameters[0]; switch (Cmd.Register) { case PICARegister.GPUREG_TEXENV_UPDATE_BUFFER: TextureEnvironments[1].Stage.UpdateColorBuffer = (Param & 0x100) != 0; TextureEnvironments[2].Stage.UpdateColorBuffer = (Param & 0x200) != 0; TextureEnvironments[3].Stage.UpdateColorBuffer = (Param & 0x400) != 0; TextureEnvironments[4].Stage.UpdateColorBuffer = (Param & 0x800) != 0; TextureEnvironments[1].Stage.UpdateAlphaBuffer = (Param & 0x1000) != 0; TextureEnvironments[2].Stage.UpdateAlphaBuffer = (Param & 0x2000) != 0; TextureEnvironments[3].Stage.UpdateAlphaBuffer = (Param & 0x4000) != 0; TextureEnvironments[4].Stage.UpdateAlphaBuffer = (Param & 0x8000) != 0; break; case PICARegister.GPUREG_TEXENV_BUFFER_COLOR: TexEnvBufferColor = new RGBA(Param); break; } } }
public static void SetVector(BinaryDeserializer Deserializer, H3DFloatKeyFrameGroup[] Vector) { uint Flags = Deserializer.Reader.ReadUInt32(); long Position = Deserializer.BaseStream.Position; uint ConstantMask = (uint)H3DAnimVectorFlags.IsXConstant; uint NotExistMask = (uint)H3DAnimVectorFlags.IsXInexistent; for (int Axis = 0; Axis < Vector.Length; Axis++) { Deserializer.BaseStream.Seek(Position, SeekOrigin.Begin); Position += 4; bool Constant = (Flags & ConstantMask) != 0; bool Exists = (Flags & NotExistMask) == 0; if (Exists) { Vector[Axis] = H3DFloatKeyFrameGroup.ReadGroup(Deserializer, Constant); } ConstantMask <<= 1; NotExistMask <<= 1; } }
public static T ReadObject <T>(Stream stream, object obj = null) { var ms = new MemoryStream(); stream.CopyTo(ms); ms.Seek(0, SeekOrigin.Begin); stream = ms; Yuzu.Deserializer.AbstractReaderDeserializer yd = null; if (CheckYuzuBinarySignature(stream)) { yd = new BinaryDeserializer { Options = defaultYuzuCommonOptions }; } else { yd = new JsonDeserializer { JsonOptions = defaultYuzuJSONOptions, Options = defaultYuzuCommonOptions }; } var bd = yd as BinaryDeserializer; if (obj == null) { return((bd != null) ? bd.FromReader <T>(new BinaryReader(stream)) : yd.FromStream <T>(stream)); } else { return((bd != null) ? (T)bd.FromReader(obj, new BinaryReader(stream)) : (T)yd.FromStream(obj, stream)); } }
private List <AclTableEntry> ParseTableEntries(ArraySegment <byte> tableSegment) { List <AclTableEntry> result; using (BinaryDeserializer binaryDeserializer = new BinaryDeserializer(tableSegment)) { List <AclTableEntry> list = FolderSecurity.AclTableEntry.ParseTableEntries <AclTableEntry>(binaryDeserializer.Reader, new Func <BinaryReader, AclTableEntry>(AclTableEntry.Parse)); HashSet <string> hashSet = null; if (list != null) { for (int i = 0; i < list.Count; i++) { AclTableEntry aclTableEntry = list[i]; if (aclTableEntry.MemberEntryId != null && aclTableEntry.MemberEntryId.Length != 0) { if (hashSet == null) { hashSet = new HashSet <string>(); } string text = AclHelper.LegacyDnFromEntryId(aclTableEntry.MemberEntryId); if (!hashSet.Add(text.ToLower())) { return(null); } } if (aclTableEntry.MemberId != 0L && aclTableEntry.MemberId != -1L) { aclTableEntry.SetMemberId(AclModifyTable.GetIdForSecurityIdentifier(aclTableEntry.SecurityIdentifier, null, this.coreFolder.AclTableIdMap)); } } } result = list; } return(result); }
private async Task LoadObject() { byte[] Key = (byte[])this.e.CurrentObjectId; BinaryDeserializer Reader = new BinaryDeserializer(this.file.CollectionName, this.file.Encoding, Key); this.recordHandler.SkipKey(Reader, true); this.currentObjectId = this.recordHandler.ObjectId; try { if (this.currentSerializer == null) { this.currentSerializer = this.provider.GetObjectSerializer(typeof(T)); } this.current = (T)await this.file.ObjectFile.LoadObject(this.currentObjectId, this.currentSerializer); this.currentTypeCompatible = true; } catch (Exception) { this.current = default(T); this.currentTypeCompatible = false; } this.hasCurrent = true; }
void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer) { PICACommandReader Reader = new PICACommandReader(Commands); while (Reader.HasCommand) { PICACommand Cmd = Reader.GetCommand(); uint Param = Cmd.Parameters[0]; switch (Cmd.Register) { case PICARegister.GPUREG_TEXENV0_SOURCE: case PICARegister.GPUREG_TEXENV1_SOURCE: case PICARegister.GPUREG_TEXENV2_SOURCE: case PICARegister.GPUREG_TEXENV3_SOURCE: case PICARegister.GPUREG_TEXENV4_SOURCE: case PICARegister.GPUREG_TEXENV5_SOURCE: Stage.Source = new PICATexEnvSource(Param); break; case PICARegister.GPUREG_TEXENV0_OPERAND: case PICARegister.GPUREG_TEXENV1_OPERAND: case PICARegister.GPUREG_TEXENV2_OPERAND: case PICARegister.GPUREG_TEXENV3_OPERAND: case PICARegister.GPUREG_TEXENV4_OPERAND: case PICARegister.GPUREG_TEXENV5_OPERAND: Stage.Operand = new PICATexEnvOperand(Param); break; case PICARegister.GPUREG_TEXENV0_COMBINER: case PICARegister.GPUREG_TEXENV1_COMBINER: case PICARegister.GPUREG_TEXENV2_COMBINER: case PICARegister.GPUREG_TEXENV3_COMBINER: case PICARegister.GPUREG_TEXENV4_COMBINER: case PICARegister.GPUREG_TEXENV5_COMBINER: Stage.Combiner = new PICATexEnvCombiner(Param); break; case PICARegister.GPUREG_TEXENV0_COLOR: case PICARegister.GPUREG_TEXENV1_COLOR: case PICARegister.GPUREG_TEXENV2_COLOR: case PICARegister.GPUREG_TEXENV3_COLOR: case PICARegister.GPUREG_TEXENV4_COLOR: case PICARegister.GPUREG_TEXENV5_COLOR: Stage.Color = new RGBA(Param); break; case PICARegister.GPUREG_TEXENV0_SCALE: case PICARegister.GPUREG_TEXENV1_SCALE: case PICARegister.GPUREG_TEXENV2_SCALE: case PICARegister.GPUREG_TEXENV3_SCALE: case PICARegister.GPUREG_TEXENV4_SCALE: case PICARegister.GPUREG_TEXENV5_SCALE: Stage.Scale = new PICATexEnvScale(Param); break; } } }
void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer) { uint[] Addresses = new uint[3]; uint ConstantMask = (uint)H3DAnimQuatTransformFlags.IsScaleConstant; uint NotExistMask = (uint)H3DAnimQuatTransformFlags.IsScaleInexistent; Addresses[0] = Deserializer.Reader.ReadUInt32(); Addresses[1] = Deserializer.Reader.ReadUInt32(); Addresses[2] = Deserializer.Reader.ReadUInt32(); for (int ElemIndex = 0; ElemIndex < 3; ElemIndex++) { bool Constant = ((uint)Flags & ConstantMask) != 0; bool Exists = ((uint)Flags & NotExistMask) == 0; if (Exists) { Deserializer.BaseStream.Seek(Addresses[ElemIndex], SeekOrigin.Begin); uint ElemFlags = 0; uint Address = Addresses[ElemIndex]; uint Count = 1; if (!Constant) { /* * gdkchan Note: * Those values have been verified and Start Frame will always be zero on observed BCHs. * This may or may not change on future versions (probably not), so we can safely ignore it. */ float StartFrame = Deserializer.Reader.ReadSingle(); float EndFrame = Deserializer.Reader.ReadSingle(); ElemFlags = Deserializer.Reader.ReadUInt32(); Address = Deserializer.Reader.ReadUInt32(); Count = Deserializer.Reader.ReadUInt32(); } Deserializer.BaseStream.Seek(Address, SeekOrigin.Begin); for (int Index = 0; Index < Count; Index++) { switch (ElemIndex) { case 0: Scales.Add(Deserializer.Reader.ReadVector3()); break; case 1: Rotations.Add(Deserializer.Reader.ReadQuaternion()); break; case 2: Translations.Add(Deserializer.Reader.ReadVector3()); break; } } } ConstantMask >>= 1; NotExistMask >>= 1; } }
void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer) { Deserializer.BaseStream.Seek(-0xc, SeekOrigin.Current); uint Flags = Deserializer.Reader.ReadUInt32(); Deserializer.BaseStream.Seek(8, SeekOrigin.Current); uint[] Addresses = new uint[3]; uint ConstantMask = (uint)GfxAnimQuatTransformFlags.IsScaleConstant; uint NotExistMask = (uint)GfxAnimQuatTransformFlags.IsScaleInexistent; Addresses[1] = Deserializer.ReadPointer(); Addresses[2] = Deserializer.ReadPointer(); Addresses[0] = Deserializer.ReadPointer(); for (int ElemIndex = 0; ElemIndex < 3; ElemIndex++) { bool Constant = (Flags & ConstantMask) != 0; bool Exists = (Flags & NotExistMask) == 0; if (Exists) { Deserializer.BaseStream.Seek(Addresses[ElemIndex], SeekOrigin.Begin); float StartFrame = Deserializer.Reader.ReadSingle(); float EndFrame = Deserializer.Reader.ReadSingle(); uint CurveRelPtr = Deserializer.Reader.ReadUInt32(); bool IsConstant = Deserializer.Reader.ReadUInt32() != 0; int Count = IsConstant ? 1 : (int)(EndFrame - StartFrame); for (int Index = 0; Index < Count; Index++) { switch (ElemIndex) { case 0: Scales.Add(Deserializer.Reader.ReadVector3()); break; case 1: Rotations.Add(Deserializer.Reader.ReadQuaternion()); break; case 2: Translations.Add(Deserializer.Reader.ReadVector3()); break; } uint SegmentFlags = Deserializer.Reader.ReadUInt32(); } } ConstantMask >>= 1; NotExistMask >>= 1; } }
void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer) { if (Deserializer.FileVersion < 0x20) { /* * Older version have a pointer within the curve data, * instead of storing it directly. So we read it below... */ Deserializer.BaseStream.Seek(Deserializer.Reader.ReadUInt32(), SeekOrigin.Begin); //We don't need this since it's already stored on Curve float StartFrame = Deserializer.Reader.ReadSingle(); float EndFrame = Deserializer.Reader.ReadSingle(); InterpolationType = (H3DInterpolationType)Deserializer.Reader.ReadByte(); Quantization = (KeyFrameQuantization)Deserializer.Reader.ReadByte(); Count = Deserializer.Reader.ReadUInt16(); InvDuration = Deserializer.Reader.ReadSingle(); ValueScale = Deserializer.Reader.ReadSingle(); ValueOffset = Deserializer.Reader.ReadSingle(); FrameScale = Deserializer.Reader.ReadSingle(); } Deserializer.BaseStream.Seek(Deserializer.Reader.ReadUInt32(), SeekOrigin.Begin); for (int Index = 0; Index < Count; Index++) { KeyFrame KF; switch (Quantization) { case KeyFrameQuantization.Hermite128: KF = Deserializer.Reader.ReadHermite128(); break; case KeyFrameQuantization.Hermite64: KF = Deserializer.Reader.ReadHermite64(); break; case KeyFrameQuantization.Hermite48: KF = Deserializer.Reader.ReadHermite48(); break; case KeyFrameQuantization.UnifiedHermite96: KF = Deserializer.Reader.ReadUnifiedHermite96(); break; case KeyFrameQuantization.UnifiedHermite48: KF = Deserializer.Reader.ReadUnifiedHermite48(); break; case KeyFrameQuantization.UnifiedHermite32: KF = Deserializer.Reader.ReadUnifiedHermite32(); break; case KeyFrameQuantization.StepLinear64: KF = Deserializer.Reader.ReadStepLinear64(); break; case KeyFrameQuantization.StepLinear32: KF = Deserializer.Reader.ReadStepLinear32(); break; default: throw new InvalidOperationException($"Invalid Segment quantization {Quantization}!"); } KF.Frame = KF.Frame * FrameScale; KF.Value = KF.Value * ValueScale + ValueOffset; KeyFrames.Add(KF); } }
public void TestBinaryReadObject() { var bd = new BinaryDeserializer(); binaryStream.Position = 0; var p = bd.FromStream(binaryStream); Assert.AreEqual(person.Name, ((SamplePerson)p).Name); }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(BinaryDeserializer Reader, uint?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBits(6); } return(ReadArray <T>(this.provider, Reader, DataType.Value)); }
/// <summary> /// Reads this object from its binary representation. /// </summary> /// <param name="deserializer">Deserializer to read the object with.</param> public void Deserialize(BinaryDeserializer deserializer) { Dictionary <object, object> attributeTable = deserializer.Deserialize <Dictionary <object, object> >(); foreach (KeyValuePair <object, object> keyValuePair in attributeTable) { this.attributes[keyValuePair.Key] = keyValuePair.Value; } }
public ILoadEntityDatabasePipeline CreateDefaultLoadPipeline(IDependencyContainer container) { var mappingRegistry = new MappingRegistry(container.Resolve <EverythingTypeMapper>()); var typeCreator = container.Resolve <ITypeCreator>(); var primitiveTypeMappings = container.ResolveAll <IBinaryPrimitiveHandler>(); var everythingDeserializer = new BinaryDeserializer(mappingRegistry, typeCreator, primitiveTypeMappings); return(CreateLoadPipeline(container, everythingDeserializer, DefaultEntityDatabaseFile)); }
public static DATA FromBytes <DATA>(byte[] Source) where DATA : class, IData, new() { GameObject Load = Resource.LoadPrefabInstance("Group"); DataWrapper LoadComponent = Load.AddComponent <DataWrapper>(); BinaryDeserializer.LoadComponentContentsFromBytes(LoadComponent, null, Source); return(LoadComponent.Data as DATA); }
public void TestBinaryRead() { var bd = new BinaryDeserializer(); SamplePerson p = new SamplePerson(); binaryStream.Position = 0; bd.FromStream(p, binaryStream); Assert.AreEqual(person.Name, p.Name); }
public void TestJsonToBinaryUnknown() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var js = new JsonSerializer(); js.JsonOptions.FieldSeparator = ""; js.JsonOptions.Indent = ""; js.JsonOptions.SaveRootClass = true; var jd = new JsonDeserializer(); var data1 = "{\"class\":\"NewType\",\"X\":\"abc\"}"; var result1 = js.ToString(bd.FromBytes(bs.ToBytes(jd.FromString(data1)))); Assert.AreEqual(data1, result1); }
public void TestAllowReadingFromAncestor() { var bs = new BinarySerializer(); var v1 = new Sample2 { X = 83, Y = "83" }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(Sample2)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 53 00 00 00 00 00", XS(result1)); var w1 = new Sample2Allow(); var bd = new BinaryDeserializer(); bd.FromBytes(w1, result1); Assert.AreEqual(v1.X, w1.X); }
public void TestBinaryToJsonUnknown() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var js = new JsonSerializer(); js.JsonOptions.SaveRootClass = true; var jd = new JsonDeserializer(); var n = "NewType".ToCharArray().Select(ch => (byte)ch).ToList(); var data1 = new byte[] { 0x20, 0x01, 0x00, (byte)n.Count }.Concat(n). Concat(new byte[] { 0x01, 0x00, 0x01, (byte)'X', (byte)RoughType.String, 0x01, 0x00, 0x03, (byte)'a', (byte)'b', (byte)'c', 0, 0 }).ToArray(); var result1 = bs.ToBytes(jd.FromString(js.ToString(bd.FromBytes(data1)))); CollectionAssert.AreEqual(data1, result1); }
public void TestAbstract() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); SampleAbstract v1 = new SampleConcrete { XX = 81 }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleConcrete)) + " 01 00 " + XS("XX", RoughType.Int) + " 01 00 51 00 00 00 00 00", XS(result1)); var w1 = bd.FromBytes<SampleAbstract>(result1); Assert.AreEqual((v1 as SampleConcrete).XX, (w1 as SampleConcrete).XX); var w1g = (SampleConcrete)(new BinaryDeserializerGen().FromBytes(result1)); Assert.AreEqual((v1 as SampleConcrete).XX, w1g.XX); var v2 = new List<SampleAbstract>(); v2.Add(new SampleConcrete { XX = 51 }); var w2 = bd.FromBytes<List<SampleAbstract>>(bs.ToBytes(v2)); Assert.AreEqual(v2.Count, w2.Count); Assert.AreEqual((v2[0] as SampleConcrete).XX, (w2[0] as SampleConcrete).XX); }
public void TestCollection() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var v0 = new SampleWithCollection(); v0.A.Add(new SampleInterfaced { X = 9 }); v0.B.Add(7); v0.B.Add(6); var result0 = bs.ToBytes(v0); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleWithCollection)) + " 02 00 " + XS("A", RoughType.Sequence) + " " + XS(RoughType.Record) + " " + XS("B", RoughType.Sequence) + " " + XS(RoughType.Int) + " 01 00 01 00 00 00 02 00 " + XS(typeof(SampleInterfaced)) + " 01 00 " + XS("X", RoughType.Int) + " 01 00 09 00 00 00 00 00" + " 02 00 02 00 00 00 07 00 00 00 06 00 00 00 00 00", XS(result0)); var w0 = new SampleWithCollection(); bd.FromBytes(w0, result0); Assert.AreEqual(1, w0.A.Count); Assert.IsInstanceOfType(w0.A.First(), typeof(SampleInterfaced)); Assert.AreEqual(9, w0.A.First().X); CollectionAssert.AreEqual(new int[] { 7, 6 }, w0.B.ToList()); var w1 = (SampleWithCollection)((new BinaryDeserializerGen()).FromBytes(result0)); Assert.AreEqual(1, w1.A.Count); Assert.IsInstanceOfType(w1.A.First(), typeof(SampleInterfaced)); Assert.AreEqual(9, w1.A.First().X); CollectionAssert.AreEqual(new int[] { 7, 6 }, w1.B.ToList()); var v2 = new SampleConcreteCollection { 2, 5, 4 }; var result1 = bs.ToBytes(v2); Assert.AreEqual("21 05 03 00 00 00 02 00 00 00 05 00 00 00 04 00 00 00", XS(result1)); SampleConcreteCollection w2 = new SampleConcreteCollection(); bd.FromBytes(w2, result1); CollectionAssert.AreEqual(v2.ToList(), w2.ToList()); }
public void TestFloat() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; var v = new SampleFloat { F = 1e-20f, D = -3.1415e100d }; var result1 = bs.ToBytes(v); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleFloat)) + " 02 00 " + XS("F", RoughType.Float, "D", RoughType.Double) + " 01 00 08 E5 3C 1E 02 00 CA DC 09 3E BE B9 CC D4 00 00", XS(result1)); var w = new SampleFloat(); var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; bd.FromBytes(w, result1); Assert.AreEqual(v.F, w.F); Assert.AreEqual(v.D, w.D); }
public void TestStruct() { var v = new SampleRect { A = new SamplePoint { X = 33, Y = 44 }, B = new SamplePoint { X = 55, Y = 66 }, }; var bs = new BinarySerializer(); var result = bs.ToBytes(v); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleRect)) + " 02 00 " + XS("A", RoughType.Record, "B", RoughType.Record) + " 01 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.Int) + " 21 00 00 00 2C 00 00 00 " + "02 00 02 00 37 00 00 00 42 00 00 00 00 00", XS(result)); var bd = new BinaryDeserializer(); var w = new SampleRect(); bd.FromBytes(w, result); CheckSampleRect(v, w); var bdg = new BinaryDeserializerGen(); w = (SampleRect)bdg.FromBytes(result); CheckSampleRect(v, w); var p = (SamplePoint)bdg.FromBytes(new SamplePoint(), SX("20 02 00 22 00 00 00 2D 00 00 00")); Assert.AreEqual(34, p.X); Assert.AreEqual(45, p.Y); }
public void Load(string path) { FileInfo file = new FileInfo(path); if (!file.Exists) { this.editorSettings.RecentProjects.Remove(path); this.SaveEditorSettings(); throw new FileNotFoundException(string.Format("Project file not found: {0}", path), path); } // Load project. FileStream fileStream = new FileStream(path, FileMode.Open); ProjectSettings newProjectSettings = (ProjectSettings)this.projectSettingsSerializer.Deserialize(fileStream); if (newProjectSettings == null) { throw new SerializationException( string.Format("Couldn't deserialize project settings from '{0}'.", path)); } fileStream.Close(); // Convert file paths. newProjectSettings.ProjectAssemblies = newProjectSettings.ProjectAssembliesSerialized.Select( assemblyPath => ReflectionUtils.FindAssembly(string.Format("{0}\\{1}", Path.GetDirectoryName(path), assemblyPath))) .ToList(); newProjectSettings.LanguageFiles = newProjectSettings.LanguageFilesSerialized.Select( languageFilePath => new LanguageFile { Path = new FileInfo(string.Format("{0}\\{1}", Path.GetDirectoryName(path), languageFilePath)) .FullName }).ToList(); for (int i = 0; i < newProjectSettings.LanguageFiles.Count; i++) { newProjectSettings.LanguageFiles[i].LanguageTag = newProjectSettings.LanguageNamesSerialized[i]; } // Load blueprint files. foreach (var blueprintFile in newProjectSettings.BlueprintFiles) { var blueprintFileName = this.ReadBlueprintsAsBinary ? Path.ChangeExtension(blueprintFile.Path, "bytes") : blueprintFile.Path; var absoluteBlueprintFilePath = string.Format( "{0}\\{1}", Path.GetDirectoryName(path), blueprintFileName); var fileInfo = new FileInfo(absoluteBlueprintFilePath); if (!fileInfo.Exists) { throw new FileNotFoundException(string.Format("Blueprint file not found: {0}.", blueprintFileName)); } using (var blueprintFileStream = fileInfo.OpenRead()) { try { BlueprintManager newBlueprintManager; if (this.ReadBlueprintsAsBinary) { var binaryDeserializer = new BinaryDeserializer(blueprintFileStream); newBlueprintManager = binaryDeserializer.Deserialize<BlueprintManager>(); } else { newBlueprintManager = (BlueprintManager)this.blueprintManagerSerializer.Deserialize(blueprintFileStream); } if (newBlueprintManager == null) { throw new SerializationException( string.Format("Couldn't deserialize blueprint manager from '{0}'.", path)); } blueprintFile.BlueprintManager = newBlueprintManager; } catch (Exception e) { throw new SerializationException( string.Format( "Couldn't deserialize blueprint manager from '{0}': {1}.", path, e.GetBaseException().Message), e); } } } // Set new project. this.SetProject(newProjectSettings, path); // Save to recent projects. this.editorSettings.AddRecentProject(path); this.SaveEditorSettings(); }
public void TestTopLevelList() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var v0 = new List<string> { "a", "b", "c" }; var result0 = bs.ToBytes(v0); Assert.AreEqual("21 10 03 00 00 00 " + XS("a", "b", "c"), XS(result0)); var w0 = new List<string>(); bd.FromBytes(w0, result0); CollectionAssert.AreEqual(v0, w0); bd.FromBytes(w0, new byte[] { 0x21, 0x10, 0, 0, 0, 0 }); CollectionAssert.AreEqual(v0, w0); bd.FromBytes(w0, result0); CollectionAssert.AreEqual(new List<string> { "a", "b", "c", "a", "b", "c" }, w0); }
/// <summary> /// Reads this object from its binary representation. /// </summary> /// <param name="deserializer">Deserializer to read the object with.</param> public void Deserialize(BinaryDeserializer deserializer) { this.AttributeTableSerialized = deserializer.Deserialize<AttributeTable>(); this.ComponentTypesSerialized = deserializer.Deserialize<string[]>(); this.ParentId = deserializer.Deserialize<string>(); }
public void TestUnknownStorage() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); bd.Options.AllowUnknownFields = true; var data = "20 01 00 " + XS(typeof(SampleUnknown)) + " 03 00 " + XS("A", RoughType.String, "X", RoughType.Int, "Z", RoughType.Bool) + " 01 00 " + XS("qq") + " 02 00 02 01 00 00 03 00 01 00 00"; var w = new SampleUnknown(); bd.FromBytes(w, SX(data)); Assert.AreEqual(258, w.X); Assert.AreEqual(2, w.Storage.Fields.Count); Assert.AreEqual("A", w.Storage.Fields[0].Name); Assert.AreEqual("qq", w.Storage.Fields[0].Value); Assert.AreEqual("Z", w.Storage.Fields[1].Name); Assert.AreEqual(true, w.Storage.Fields[1].Value); Assert.AreEqual(data, XS(bs.ToBytes(w))); bd.FromBytes(w, SX("20 01 00 00 00")); Assert.AreEqual(0, w.Storage.Fields.Count); Assert.AreEqual("20 01 00 00 00", XS(bs.ToBytes(new SampleUnknown()))); bd.ClearClassIds(); bs.ClearClassIds(); bd.FromBytes(w, SX( "20 01 00 " + XS(typeof(SampleUnknown)) + " 02 00 " + XS("A", RoughType.String, "Z", RoughType.Bool) + " 01 00 " + XS("tt") + " 02 00 01 00 00")); Assert.AreEqual(2, w.Storage.Fields.Count); Assert.AreEqual("A", w.Storage.Fields[0].Name); Assert.AreEqual("tt", w.Storage.Fields[0].Value); Assert.AreEqual("Z", w.Storage.Fields[1].Name); Assert.AreEqual(true, w.Storage.Fields[1].Value); Assert.AreEqual(258, w.X); w.X = 0; Assert.AreEqual( "20 01 00 " + XS(typeof(SampleUnknown)) + " 03 00 " + XS("A", RoughType.String, "X", RoughType.Int, "Z", RoughType.Bool) + " 01 00 " + XS("tt") + " 03 00 01 00 00", XS(bs.ToBytes(w))); bs.ClearClassIds(); bs.ToBytes(new SampleUnknown()); XAssert.Throws<YuzuException>(() => bs.ToBytes(w), "SampleUnknown"); bs.ClearClassIds(); bd.ClearClassIds(); var data2 = "20 01 00 " + XS(typeof(SampleUnknown)) + " 02 00 " + XS("A", RoughType.Record, "X", RoughType.Int) + " 01 00 02 00 " + XS("NewType") + " 01 00 " + XS("Fld", RoughType.SByte) + " 01 00 FE 00 00 02 00 14 00 00 00 00 00"; var w2 = bd.FromBytes<SampleUnknown>(SX(data2)); Assert.AreEqual(1, w2.Storage.Fields.Count); Assert.AreEqual("A", w2.Storage.Fields[0].Name); var u2 = (YuzuUnknown)w2.Storage.Fields[0].Value; Assert.AreEqual("NewType", u2.ClassTag); Assert.AreEqual(1, u2.Fields.Count); Assert.AreEqual((sbyte)-2, u2.Fields["Fld"]); Assert.AreEqual(20, w2.X); Assert.AreEqual("\n" + data2, "\n" + XS(bs.ToBytes(w2))); }
public void TestNewFields() { var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Aliases; bd.Options.AllowUnknownFields = true; var w = new SampleTree(); bd.FromBytes(w, SX( "20 01 00 " + XS(typeof(SampleTree)) + " 03 00 " + XS("a", RoughType.Int, "a1", RoughType.Sequence) + " 10 " + XS("b", RoughType.Sequence) + " 20 01 00 09 00 00 00 02 00 00 00 00 00 03 00 FF FF FF FF 00 00")); Assert.AreEqual(9, w.Value); Assert.AreEqual(null, w.Children); bd.ClearClassIds(); bd.FromBytes(w, SX( "20 01 00 " + XS(typeof(SampleTree)) + " 04 00 " + XS("a", RoughType.Int, "a1", RoughType.Byte) + " " + XS("b", RoughType.Sequence) + " 20 " + XS("x", RoughType.Record) + " 01 00 0A 00 00 00 02 00 00 04 00 00 00 00 00")); Assert.AreEqual(10, w.Value); bd.FromBytes(w, SX( "20 01 00 01 00 0B 00 00 00 00 00")); Assert.AreEqual(11, w.Value); }
public void TestNested() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; var v = new Sample3 { S1 = new Sample1 { X = 345, Y = "test" }, F = 222, S2 = new Sample2 { X = -346, Y = "test1" }, }; var result = bs.ToBytes(v); Assert.AreEqual( "20 01 00 " + XS(typeof(Sample3)) + " 03 00 " + XS("S1", RoughType.Record, "F", RoughType.Int, "S2", RoughType.Record) + " 01 00 02 00 " + XS(typeof(Sample1)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 59 01 00 00 02 00 " + XS("test") + " 00 00 " + "02 00 DE 00 00 00 " + "03 00 03 00 " + XS(typeof(Sample2)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 A6 FE FF FF 02 00 " + XS("test1") + " 00 00 00 00", XS(result)); var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; var w = new Sample3(); bd.FromBytes(w, result); Assert.AreEqual(v.S1.X, w.S1.X); Assert.AreEqual(v.S1.Y, w.S1.Y); Assert.AreEqual(v.F, w.F); Assert.AreEqual(v.S2.X, w.S2.X); Assert.AreEqual(v.S2.Y, w.S2.Y); }
public void TestArray() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var bdg = new BinaryDeserializerGen(); var v0 = new SampleArray { A = new string[] { "a", "b", "c" } }; var result0 = bs.ToBytes(v0); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleArray)) + " 01 00 " + XS("A", RoughType.Sequence) + " 10 01 00 03 00 00 00 " + XS("a", "b", "c") + " 00 00", XS(result0)); var w0 = new SampleArray(); bd.FromBytes(w0, result0); CollectionAssert.AreEqual(v0.A, w0.A); var w0g = (SampleArray)bdg.FromBytes(result0); CollectionAssert.AreEqual(v0.A, w0g.A); var v2 = new SampleArray(); var result2 = bs.ToBytes(v2); Assert.AreEqual("20 01 00 01 00 FF FF FF FF 00 00", XS(result2)); var w2 = new SampleArray(); bd.FromBytes(w2, result2); CollectionAssert.AreEqual(v2.A, w2.A); var w2g = (SampleArray)bdg.FromBytes(result2); CollectionAssert.AreEqual(v2.A, w2g.A); }
public void TestMemberOfInterface() { var bs = new BinarySerializer(); var v1 = new List<ISampleMember>(); var result1 = bs.ToBytes(v1); Assert.AreEqual("21 20 00 00 00 00", XS(result1)); var bd = new BinaryDeserializer(); var w1 = new List<ISampleMember>(); bd.FromBytes(w1, result1); Assert.AreEqual(0, w1.Count); v1.Add(new SampleMemberI()); var result2 = bs.ToBytes(v1); Assert.AreEqual( "21 20 01 00 00 00 01 00 " + XS(typeof(SampleMemberI)) + " 01 00 " + XS("X", RoughType.Int) + " 00 00", XS(result2)); bd.FromBytes(w1, result2); Assert.AreEqual(71, w1[0].X); Assert.AreEqual("21 20 00 00 00 00", XS(bs.ToBytes(new List<SampleMemberAbstract>()))); var v3 = new List<SampleMemberAbstract> { new SampleMemberConcrete() }; var result3 = bs.ToBytes(v3); Assert.AreEqual( "21 20 01 00 00 00 02 00 " + XS(typeof(SampleMemberConcrete)) + " 01 00 " + XS("X", RoughType.Int) + " 00 00", XS(result3)); var w3 = new List<SampleMemberAbstract>(); bd.FromBytes(w3, result3); Assert.AreEqual(72, w3[0].X); }
public void TestLong() { var bs = new BinarySerializer(); var v1 = new SampleLong { S = -1L << 33, U = 1UL << 33 }; var result = bs.ToBytes(v1); Assert.AreEqual( XS(RoughType.Record) + " 01 00 " + XS(typeof(SampleLong)) + " 02 00 " + XS("S", RoughType.Long, "U", RoughType.ULong) + " 01 00 00 00 00 00 FE FF FF FF 02 00 00 00 00 00 02 00 00 00 00 00", XS(result)); var v2 = new SampleLong(); var bd = new BinaryDeserializer(); bd.FromBytes(v2, result); Assert.AreEqual(v1.S, v2.S); Assert.AreEqual(v1.U, v2.U); v1.S = long.MinValue; v1.U = ulong.MaxValue; bd.FromBytes(v2, bs.ToBytes(v1)); Assert.AreEqual(v1.S, v2.S); Assert.AreEqual(v1.U, v2.U); }
public void TestList() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; var v0 = new SampleList { E = new List<string> { "a", "b", "c" } }; var result0 = bs.ToBytes(v0); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleList)) + " 01 00 " + XS("E", RoughType.Sequence) + " " + XS(RoughType.String) + " 01 00 03 00 00 00 " + XS("a", "b", "c") + " 00 00", XS(result0)); var w0 = new SampleList(); bd.FromBytes(w0, result0); CollectionAssert.AreEqual(v0.E, w0.E); var v1 = new SampleTree { Value = 11, Children = new List<SampleTree>() }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 02 00 " + XS(typeof(SampleTree)) + " 02 00 " + XS("Value", RoughType.Int, "Children", RoughType.Sequence) + " " + XS(RoughType.Record) + " 01 00 0B 00 00 00 02 00 00 00 00 00 00 00", XS(result1)); Assert.AreEqual("20 02 00 01 00 0B 00 00 00 02 00 00 00 00 00 00 00", XS(bs.ToBytes(v1))); var w1 = new SampleTree(); bd.FromBytes(w1, result1); Assert.AreEqual(0, w1.Children.Count); var v2 = new SampleTree { Value = 11, Children = new List<SampleTree> { new SampleTree { Value = 12, Children = new List<SampleTree>(), }, new SampleTree { Value = 13, } } }; var result2 = bs.ToBytes(v2); Assert.AreEqual( "20 02 00 01 00 0B 00 00 00 02 00 02 00 00 00 " + "02 00 01 00 0C 00 00 00 02 00 00 00 00 00 00 00 " + "02 00 01 00 0D 00 00 00 02 00 FF FF FF FF 00 00 00 00", XS(result2)); SampleTree w2 = new SampleTree(); bd.FromBytes(w2, result2); Assert.AreEqual(v2.Value, w2.Value); Assert.AreEqual(v2.Children.Count, w2.Children.Count); Assert.AreEqual(v2.Children[0].Value, w2.Children[0].Value); Assert.AreEqual(v2.Children[1].Children, w2.Children[1].Children); Assert.AreEqual( "20 03 00 " + XS(typeof(SampleEmptyList)) + " 01 00 " + XS("E", RoughType.Sequence) + " " + XS(RoughType.String) + " 00 00", XS(bs.ToBytes(new SampleEmptyList()))); Assert.AreEqual( "20 03 00 01 00 FF FF FF FF 00 00", XS(bs.ToBytes(new SampleEmptyList { E = null }))); }
public void TestClassNames() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; Assert.AreEqual( "20 01 00 " + XS(typeof(SampleBase)) + " 01 00 " + XS("FBase", RoughType.Int) + " 01 00 00 00 00 00 00 00", XS(bs.ToBytes(new SampleBase()))); Assert.AreEqual( "20 02 00 " + XS(typeof(SampleDerivedA)) + " 02 00 " + XS("FBase", RoughType.Int, "FA", RoughType.Int) + " 01 00 00 00 00 00 02 00 00 00 00 00 00 00", XS(bs.ToBytes(new SampleDerivedA()))); var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; var v = bd.FromBytes(SX( "20 01 00 " + XS(typeof(SampleDerivedB)) + " 02 00 " + XS("FBase", RoughType.Int, "FB", RoughType.Int) + " 01 00 03 00 00 00 02 00 07 00 00 00 00 00")); Assert.IsInstanceOfType(v, typeof(SampleDerivedB)); var b = (SampleDerivedB)v; Assert.AreEqual(3, b.FBase); Assert.AreEqual(7, b.FB); }
public void TestBool() { var bs = new BinarySerializer(); var v = new SampleBool { B = true }; var result1 = bs.ToBytes(v); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleBool)) + " 01 00 " + XS("B", RoughType.Bool) + " 01 00 01 00 00", XS(result1)); var bd = new BinaryDeserializer(); var w = new SampleBool(); bd.FromBytes(w, result1); Assert.AreEqual(true, w.B); }
public void TestEscape() { var bs = new BinarySerializer(); var s = "\"/{\u0001}\n\t\"\""; var v = new Sample1 { Y = s }; var result = bs.ToBytes(v); Assert.AreEqual( "20 01 00 " + XS(typeof(Sample1)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 00 00 00 00 02 00 " + XS(s) + " 00 00", XS(result)); var w = new Sample1(); var bd = new BinaryDeserializer(); bd.FromBytes(w, result); Assert.AreEqual(s, w.Y); v.Y = "привет"; var result2 = bs.ToBytes(v); Assert.AreEqual( "20 01 00 01 00 00 00 00 00 02 00 0C " + XS(Encoding.UTF8.GetBytes("привет")) + " 00 00", XS(result2)); bd.FromBytes(w, result2); Assert.AreEqual(v.Y, w.Y); var ms = new MemoryStream(result2.Length); ms.Write(result2, 0, result2.Length); ms.Position = 0; bd.FromReader(w, new UnsafeBinaryReader(ms)); Assert.AreEqual(v.Y, w.Y); }
public void TestUnknown() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var data1 = SX( "20 01 00 " + XS("NewType1") + " 02 00 " + XS("a", RoughType.Int, "b", RoughType.String) + " 01 00 07 07 00 00 00 00"); var w1 = (YuzuUnknown)bd.FromBytes<object>(data1); Assert.AreEqual("NewType1", w1.ClassTag); Assert.AreEqual(1, w1.Fields.Count); Assert.AreEqual(7*256 + 7, w1.Fields["a"]); CollectionAssert.AreEqual(data1, bs.ToBytes(w1)); var data2 = SX("20 01 00 02 00 " + XS("qwe") + " 00 00"); var w2 = (YuzuUnknown)bd.FromBytes(data2); Assert.AreEqual("NewType1", w2.ClassTag); Assert.AreEqual(1, w2.Fields.Count); Assert.AreEqual("qwe", w2.Fields["b"]); CollectionAssert.AreEqual(data2, bs.ToBytes(w2)); var data3 = SX( "20 02 00 " + XS(typeof(SampleBool)) + " 02 00 " + XS("B", RoughType.Bool, "a", RoughType.Record) + " 01 00 01 02 00 03 00 " + XS("NewType2") + " 00 00 00 00 00 00"); bd.Options.AllowUnknownFields = true; var w3 = bd.FromBytes<SampleBool>(data3); Assert.AreEqual(true, w3.B); }
public void TestDictionary() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; var bdg = new BinaryDeserializer(); bdg.Options.TagMode = TagMode.Names; var v0 = new SampleDict { Value = 3, Children = new Dictionary<string, SampleDict> { { "a", new SampleDict { Value = 5, Children = new Dictionary<string, SampleDict>() } }, { "b", new SampleDict { Value = 7 } }, } }; var result0 = bs.ToBytes(v0); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleDict)) + " 02 00 " + XS("Value", RoughType.Int, "Children", RoughType.Mapping) + " 10 20" + " 01 00 03 00 00 00 02 00 02 00 00 00 " + XS("a") + " 01 00 01 00 05 00 00 00 02 00 00 00 00 00 00 00 " + XS("b") + " 01 00 01 00 07 00 00 00 02 00 FF FF FF FF 00 00 00 00", XS(result0)); var w0 = new SampleDict(); bd.FromBytes(w0, result0); Assert.AreEqual(v0.Value, w0.Value); Assert.AreEqual(v0.Children.Count, w0.Children.Count); Assert.AreEqual(v0.Children["a"].Value, w0.Children["a"].Value); var w1 = (SampleDict)bdg.FromBytes(result0); Assert.AreEqual(v0.Value, w1.Value); Assert.AreEqual(v0.Children.Count, w1.Children.Count); Assert.AreEqual(v0.Children["a"].Value, w1.Children["a"].Value); }
public void TestTopLevelListOfNonPrimitiveTypes() { var bs = new BinarySerializer(); bs.Options.TagMode = TagMode.Names; var bd = new BinaryDeserializer(); bd.Options.TagMode = TagMode.Names; var v1 = new List<SampleDerivedB> { new SampleDerivedB { FB = 10 }, new SampleDerivedB { FB = 20 } }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "21 20 02 00 00 00 01 00 " + XS(typeof(SampleDerivedB)) + " 02 00 " + XS("FBase", RoughType.Int, "FB", RoughType.Int) + " 01 00 00 00 00 00 02 00 0A 00 00 00 00 00 " + "01 00" + " 01 00 00 00 00 00 02 00 14 00 00 00 00 00", XS(result1)); var w1 = (List<object>)bd.FromBytes(result1); for (int i = 0; i < v1.Count; i++) { Assert.AreEqual(v1[i].FB, (w1[i] as SampleDerivedB).FB); } }
public void TestDelegate() { var bs = new BinarySerializer(); var v1 = new SampleSelfDelegate { x = 77 }; v1.OnSomething = v1.Handler1; var result = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleSelfDelegate)) + " 02 00 " + XS("OnSomething", RoughType.Record, "x", RoughType.Int) + " 01 00 " + XS("Handler1") + " 02 00 4D 00 00 00 00 00", XS(result)); var w1 = new SampleSelfDelegate(); var bd = new BinaryDeserializer(); bd.FromBytes(w1, result); Assert.AreEqual(v1.x, w1.x); w1.OnSomething(10); Assert.AreEqual(87, w1.x); result[69]++; // Replace("Handler1", "Handler2") (new BinaryDeserializer()).FromBytes(w1, result); w1.OnSomething(10); Assert.AreEqual(770, w1.x); }
/// <summary> /// Reads this object from its binary representation. /// </summary> /// <param name="deserializer">Deserializer to read the object with.</param> public void Deserialize(BinaryDeserializer deserializer) { this.AdditionalComponentTypes = deserializer.Deserialize<string[]>().Select<string, Type>(ReflectionUtils.FindType).ToList(); this.BlueprintId = deserializer.Deserialize<string>(); this.Configuration = deserializer.Deserialize<AttributeTable>(); }
public void TestDefault() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var bdg = new BinaryDeserializerGen(); var v1 = new Sample1 { X = 6, Y = "ttt" }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(Sample1)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 06 00 00 00 00 00", XS(result1)); var w1 = (Sample1)bd.FromBytes(result1); Assert.AreEqual(6, w1.X); Assert.AreEqual("zzz", w1.Y); var w1g = (Sample1)bdg.FromBytes(result1); Assert.AreEqual(6, w1g.X); Assert.AreEqual("zzz", w1g.Y); var v2 = new Sample2 { X = 5, Y = "5" }; var result2 = bs.ToBytes(v2); Assert.AreEqual( "20 02 00 " + XS(typeof(Sample2)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) + " 01 00 05 00 00 00 00 00", XS(result2)); Assert.IsInstanceOfType(bd.FromBytes(result2), typeof(Sample2)); var v3 = new SampleDefault(); var result3 = bs.ToBytes(new SampleDefault()); Assert.AreEqual( "20 03 00 " + XS(typeof(SampleDefault)) + " 03 00 " + XS("A", RoughType.Int, "B", RoughType.String, "P", RoughType.Record) + " 00 00", XS(result3)); Assert.IsInstanceOfType(bd.FromBytes(result3), typeof(SampleDefault)); v3.B = "z"; var result3m = bs.ToBytes(v3); Assert.AreEqual("20 03 00 02 00 " + XS("z") + " 00 00", XS(result3m)); var w3 = new SampleDefault(); bd.FromBytes(w3, result3m); Assert.AreEqual(3, w3.A); Assert.AreEqual("z", w3.B); Assert.AreEqual(new SamplePoint { X = 7, Y = 2 }, w3.P); var result4 = SX( "20 01 00 " + XS(typeof(SampleDefault)) + " 02 00 " + XS("A", RoughType.Int, "P", RoughType.Record) + " 01 00 05 00 00 00 " + "02 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.Int) + " 04 00 00 00 06 00 00 00 " + "00 00" ); bdg.ClearClassIds(); var w4 = bdg.FromBytes<SampleDefault>(result4); Assert.AreEqual(5, w4.A); Assert.AreEqual("default", w4.B); Assert.AreEqual(new SamplePoint { X = 4, Y = 6 }, w4.P); }
public void TestTopLevelDict() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var v0 = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } }; var result0 = bs.ToBytes(v0); Assert.AreEqual( "22 10 05 02 00 00 00 " + XS("a") + " 01 00 00 00 " + XS("b") + " 02 00 00 00", XS(result0)); var w0 = new Dictionary<string, int>(); bd.FromBytes(w0, result0); CollectionAssert.AreEqual(v0, w0); bd.FromBytes(w0, new byte[] { 0x22, 0x10, 05, 0, 0, 0, 0 }); CollectionAssert.AreEqual(v0, w0); bd.FromBytes(w0, SX("22 10 05 01 00 00 00 " + XS("c") + " 03 00 00 00")); CollectionAssert.AreEqual( new Dictionary<string, int> { { "a", 1 }, { "b", 2 }, { "c", 3 } }, w0); }
public void TestDate() { var bs = new BinarySerializer(); var bd = new BinaryDeserializer(); var v1 = new SampleDate { D = new DateTime(2011, 3, 25), T = TimeSpan.FromMinutes(5) }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleDate)) + " 02 00 " + XS("D", RoughType.DateTime, "T", RoughType.TimeSpan) + " 01 00 00 00 F5 B7 96 B8 CD 08 02 00 00 5E D0 B2 00 00 00 00 00 00", XS(result1)); var w1 = new SampleDate(); bd.FromBytes(w1, result1); Assert.AreEqual(v1.D, w1.D); Assert.AreEqual(v1.T, w1.T); var v2 = new DateTime(2011, 3, 25, 1, 2, 3, DateTimeKind.Utc); var result2 = bs.ToBytes(v2); var w2 = bd.FromBytes<DateTime>(result2); Assert.AreEqual(v2, w2); Assert.AreEqual(v2.Kind, w2.Kind); var v3 = new DateTime(2011, 3, 25, 1, 2, 3, DateTimeKind.Local); var result3 = bs.ToBytes(v3); var w3 = bd.FromBytes<DateTime>(result3); Assert.AreEqual(v3, w3); Assert.AreEqual(v3.Kind, w3.Kind); }
public void TestErrors() { var bd = new BinaryDeserializer(); bd.Options.AllowEmptyTypes = true; var bdg = new BinaryDeserializerGenerator(); XAssert.Throws<YuzuException>(() => bdg.Generate<ISample>(), "ISample"); XAssert.Throws<YuzuException>(() => bdg.Generate<SampleAbstract>(), "SampleAbstract"); XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 0xFF }), "255"); XAssert.Throws<YuzuException>(() => bd.FromBytes(new byte[] { 0xFF }), "255"); XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 0xFF }), "255"); XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 07 }), "Int32"); XAssert.Throws<YuzuException>(() => bd.FromBytes(new byte[] { (byte)RoughType.Any }), "pure"); XAssert.Throws<YuzuException>(() => bd.FromBytes<Sample1>(SX( "20 01 00 " + XS("notype") + " 00 00 00 00" )), "YuzuUnknown"); var w = new Sample1(); XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX( "20 02 00 " + XS(typeof(Empty)) + " 00 00 00 00" )), "Sample1"); var w2 = new Sample2Allow(); XAssert.Throws<YuzuException>(() => bd.FromBytes(w2, SX( "20 02 00 00 00" )), "Sample2Allow"); XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX("20 05 00")), "5"); XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX( "20 03 00 " + XS(typeof(Sample1)) + " 00 00 00 00" )), " X "); XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX( "20 03 00 " + XS(typeof(Empty)) + " 00 01 " + XS("New", RoughType.Int) + " 00 00" )), "New"); XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX( "20 03 00 " + XS(typeof(Sample1)) + " 00 01 " + XS("X", RoughType.String) + " 00 00" )), "Int32"); }
public void TestInterface() { var bs = new BinarySerializer(); var v1 = new SampleInterfaceField { I = new SampleInterfaced { X = 34 } }; var result1 = bs.ToBytes(v1); Assert.AreEqual( "20 01 00 " + XS(typeof(SampleInterfaceField)) + " 01 00 " + XS("I", RoughType.Record) + " 01 00 02 00 " + XS(typeof(SampleInterfaced)) + " 01 00 " + XS("X", RoughType.Int) + " 01 00 22 00 00 00 00 00 00 00", XS(result1)); var w1 = new SampleInterfaceField(); var bd = new BinaryDeserializer(); bd.FromBytes(w1, result1); Assert.IsInstanceOfType(w1.I, typeof(SampleInterfaced)); Assert.AreEqual(34, w1.I.X); var w1g = new SampleInterfaceField(); var bdg = new BinaryDeserializerGen(); bdg.FromBytes(w1g, result1); Assert.IsInstanceOfType(w1g.I, typeof(SampleInterfaced)); Assert.AreEqual(34, w1g.I.X); var w1n = (SampleInterfaceField)bd.FromBytes(new byte[] { 0x20, 01, 00, 01, 00, 00, 00, 00, 00 }); Assert.AreEqual(null, w1n.I); var w1ng = (SampleInterfaceField)bdg.FromBytes(new byte[] { 0x20, 01, 00, 01, 00, 00, 00, 00, 00 }); Assert.AreEqual(null, w1ng.I); var v2 = new List<ISample> { null, new SampleInterfaced { X = 37 } }; var result2 = bs.ToBytes(v2); Assert.AreEqual("21 20 02 00 00 00 00 00 02 00 01 00 25 00 00 00 00 00", XS(result2)); var w2 = new List<ISample>(); bd.FromBytes(w2, result2); Assert.AreEqual(2, w2.Count); Assert.IsNull(w2[0]); Assert.AreEqual(37, w2[1].X); ISampleField v3 = new SampleInterfacedField { X = 41 }; var result3 = bs.ToBytes(v3); Assert.AreEqual( "20 03 00 " + XS(typeof(SampleInterfacedField)) + " 01 00 " + XS("X", RoughType.Int) + " 01 00 29 00 00 00 00 00", XS(result3)); var w3 = (ISampleField)bd.FromBytes(result3); Assert.AreEqual(41, w3.X); }