/// <summary> /// Serialize logic /// </summary> /// <param name="serializer">Serializer</param> /// <param name="writer">Writer</param> /// <param name="settings">Settings</param> /// <returns>How many bytes have been written</returns> public int Serialize(IBinarySerializer serializer, BinaryWriter writer, BinarySerializerSettings settings = null) { // Write type and version var ret = 2; writer.Write((byte)Type); writer.Write(Version); // Serialize exclusive data ret += SerializeExclusiveData(serializer, writer, settings); // Serialize shared content ret += serializer.Serialize(Attributes, writer, settings); ret += serializer.Serialize(Inputs, writer, settings); ret += serializer.Serialize(Outputs, writer, settings); // Serialize sign if (settings?.Filter?.Invoke(nameof(Witness)) != false) { ret += serializer.Serialize(Witness, writer, settings); } return(ret); }
/// <summary> /// Converts to the format /// </summary> /// <returns>The task</returns> public override async Task ConvertToAsync() { var settings = new BinarySerializerSettings(Endian.Little, Encoding.GetEncoding(437)); await ConvertToAsync(settings, (filePath, format) => { // Read the data return(DeserializeJSON <Rayman1PCSaveData>(filePath)); }, new FileFilterItem("*.json", "JSON").ToString(), new FileExtension(".SAV"), null, new Rayman12PCSaveDataEncoder()); }
/// <summary> /// Converts from the format /// </summary> /// <returns>The task</returns> public override async Task ConvertFromAsync() { var settings = new BinarySerializerSettings(Endian.Little, Encoding.GetEncoding(437)); await ConvertFromAsync <Rayman1PCSaveData>(settings, (data, filePath) => { // Save the data SerializeJSON(data, filePath); }, new FileFilterItem("*.SAV", "SAV").ToString(), new[] { ".json" }, Games.Rayman1.GetInstallDir(false), new Rayman12PCSaveDataEncoder()); }
/// <summary> /// Deserialize logic /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="settings">Settings</param> public void Deserialize(IBinarySerializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { // Check type // Byte already readed // if ((byte)Type != reader.ReadByte()) // throw new FormatException(); // Read version Version = reader.ReadByte(); // Deserialize exclusive data DeserializeExclusiveData(deserializer, reader, settings); // Deserialize shared content Attributes = deserializer.Deserialize <TransactionAttribute[]>(reader, settings); if (Attributes.Length > ushort.MaxValue) { throw new FormatException(nameof(Attributes)); } Inputs = deserializer.Deserialize <CoinReference[]>(reader, settings); if (Inputs.Length > ushort.MaxValue) { throw new FormatException(nameof(Inputs)); } Outputs = deserializer.Deserialize <TransactionOutput[]>(reader, settings); if (Outputs.Length > ushort.MaxValue) { throw new FormatException(nameof(Outputs)); } // Deserialize signature if (settings?.Filter?.Invoke(nameof(Witness)) != false) { Witness = deserializer.Deserialize <Witness[]>(reader, settings); if (Witness.Length > ushort.MaxValue) { throw new FormatException(nameof(Witness)); } } }
/// <summary> /// Serialize logic /// </summary> /// <param name="serializer">Serializer</param> /// <param name="writer">Writer</param> /// <param name="settings">Settings</param> /// <returns>How many bytes have been written</returns> protected virtual int SerializeExclusiveData(IBinarySerializer serializer, BinaryWriter writer, BinarySerializerSettings settings = null) { return(0); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { return(Serializer.Serialize(serializer, writer, value, settings)); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var ar = (Array)value; if (ar == null) { return(writer.WriteVarInt(0)); } var x = writer.WriteVarInt(ar.Length); if (x > MaxLength) { throw new FormatException(nameof(MaxLength)); } foreach (var o in ar) { x += _serializer.Serialize(serializer, writer, o, settings); } return(x); }
public object Deserialize(IBinaryDeserializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { return(reader.ReadDouble()); }
protected override void DeserializeExclusiveData(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { Descriptors = deserializer.Deserialize <StateDescriptor[]>(reader, settings); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var data = Encoding.UTF8.GetBytes((string)value); if (data.Length >= MaxLength) { throw new FormatException(nameof(MaxLength)); } return(writer.WriteVarBytes(data)); }
protected override void DeserializeExclusiveData(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { Script = reader.ReadVarBytes(); ParameterList = reader.ReadVarBytes().Select(p => (ContractParameterType)p).ToArray(); ReturnType = (ContractParameterType)reader.ReadByte(); if (Version >= 1) { NeedStorage = reader.ReadBoolean(); } else { NeedStorage = false; } Name = reader.ReadVarString(252); CodeVersion = reader.ReadVarString(252); Author = reader.ReadVarString(252); Email = reader.ReadVarString(252); Description = reader.ReadVarString(65536); }
protected override void DeserializeExclusiveData(IBinarySerializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { PublicKey = deserializer.Deserialize <ECPoint>(reader, settings); }
public int Serialize(IBinarySerializer binarySerializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var ec = (ECPoint)value; writer.Write(ec.EncodedData, 0, ec.EncodedData.Length); return(ec.EncodedData.Length); }
const int expectedLength = 32;// (curve.Q.GetBitLength() + 7) / 8; public object Deserialize(IBinaryDeserializer binaryDeserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { var prefix = reader.ReadByte(); switch (prefix) { case 0x00: return(ECPoint.Infinity); case 0x02: case 0x03: { byte[] buffer = new byte[1 + expectedLength]; buffer[0] = prefix; reader.Read(buffer, 1, expectedLength); return(new ECPoint(buffer)); } case 0x04: case 0x06: case 0x07: { byte[] buffer = new byte[1 + expectedLength * 2]; buffer[0] = prefix; reader.Read(buffer, 1, expectedLength * 2); return(new ECPoint(buffer)); } default: throw new FormatException("Invalid point encoding " + prefix); } }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var tx = (Transaction)value; return(tx.Serialize(serializer, writer, settings)); }
public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { // Read transaction Type var tx = Cache.CreateInstance <Transaction>(reader.ReadByte()); tx.Deserialize(deserializer, reader, settings); return(tx); }
public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { var ret = Serializer.Deserialize(deserializer, reader, type, settings); // TODO: Check if values outside the enum throw an exception (should throw it) return(Enum.ToObject(Type, ret)); }
/// <summary> /// Deserialize object /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="type">Type</param> /// <param name="settings">Settings</param> /// <returns>Deserialized object</returns> public object Deserialize(IBinaryDeserializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { var ret = Activator.CreateInstance(type); foreach (var e in _entries) { if (settings?.Filter?.Invoke(e.Name) == false) { continue; } if (e.ReadOnly) { // Consume it var val = e.Serializer.Deserialize(deserializer, reader, e.Type, settings); // Should be equal if (!val.Equals(e.GetValue(ret))) { // If a readonly property or field is not the same, throw and exception ! throw new FormatException(); } continue; } e.SetValue(ret, e.Serializer.Deserialize(deserializer, reader, e.Type, settings)); } if (ret is IBinaryVerifiable v && !v.Verify()) { throw new FormatException(); } return(ret); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var ar = (byte[])value; if (ar == null) { return(writer.WriteVarInt(0)); } if (ar.Length > MaxLength) { throw new FormatException(nameof(MaxLength)); } return(writer.WriteVarBytes(ar)); }
/// <summary> /// Serialize /// </summary> /// <param name="serializer">Serializer</param> /// <param name="bw">Stream</param> /// <param name="obj">Object</param> /// <param name="settings">Settings</param> public int Serialize(IBinarySerializer serializer, BinaryWriter bw, object obj, BinarySerializerSettings settings = null) { if (settings != null && settings.Filter != null) { return(_entries.Where(e => settings.Filter.Invoke(e.Name) != false) .Sum(e => e.Serializer.Serialize(serializer, bw, e.GetValue(obj)))); } else { return(_entries.Sum(e => e.Serializer.Serialize(serializer, bw, e.GetValue(obj)))); } }
protected override int SerializeExclusiveData(IBinarySerializer serializer, BinaryWriter writer, BinarySerializerSettings settings = null) { var l = writer.WriteVarBytes(Script); l += writer.WriteVarBytes(ParameterList.Cast <byte>().ToArray()); writer.Write((byte)ReturnType); l++; if (Version >= 1) { writer.Write(NeedStorage); l++; } l += writer.WriteVarString(Name); l += writer.WriteVarString(CodeVersion); l += writer.WriteVarString(Author); l += writer.WriteVarString(Email); l += writer.WriteVarString(Description); return(l); }
/// <summary> /// Deserialize /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="settings">Settings</param> /// <returns>Deserialized object</returns> public T Deserialize <T>(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { return((T)Deserialize(deserializer, reader, Type, settings)); }
public object Deserialize(IBinaryDeserializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { return(reader.ReadVarString(MaxLength)); }
/// <summary> /// Deserialize object /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="settings">Settings</param> /// <returns>Deserialized object</returns> public object Deserialize(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { return(Deserialize(deserializer, reader, Type, settings)); }
protected override int SerializeExclusiveData(IBinarySerializer serializer, BinaryWriter writer, BinarySerializerSettings settings = null) { return(serializer.Serialize(Descriptors, writer, settings)); }
/// <summary> /// Deserialize object /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="type">Type</param> /// <param name="settings">Settings</param> /// <returns>Deserialized object</returns> public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { object ret; if (_constructorIndexes != null) { // Cache properties var dic = new Dictionary <BinarySerializerCacheEntry, object>(); foreach (var e in _entries) { if (settings?.Filter?.Invoke(e.Name) == false) { continue; } dic.Add(e, e.Serializer.Deserialize(deserializer, reader, e.Type, settings)); } // Call constructor var args = new object[_constructorIndexes.Length]; for (var x = args.Length - 1; x >= 0; x--) { // Don't set again the property if (dic.Remove(_constructorIndexes[x], out var value)) { args[x] = value; } } // Create instance ret = Activator.CreateInstance(type, args); // Set other properties foreach (var e in dic) { switch (e.Key.ValueHandlerLogic) { case ValueHandlerLogicType.Writable: { e.Key.SetValue(ret, e.Value); break; } case ValueHandlerLogicType.JustConsume: break; case ValueHandlerLogicType.MustBeEqual: { if (!e.Value.Equals(e.Key.GetValue(ret))) { // If a readonly property or field is not the same, throw and exception ! throw new FormatException(e.Key.Name); } break; } } } } else { // Faster way ret = Activator.CreateInstance(type); foreach (var e in _entries) { if (settings?.Filter?.Invoke(e.Name) == false) { continue; } switch (e.ValueHandlerLogic) { case ValueHandlerLogicType.Writable: { e.SetValue(ret, e.Serializer.Deserialize(deserializer, reader, e.Type, settings)); break; } case ValueHandlerLogicType.JustConsume: { // Consume it e.Serializer.Deserialize(deserializer, reader, e.Type, settings); break; } case ValueHandlerLogicType.MustBeEqual: { // Consume it var val = e.Serializer.Deserialize(deserializer, reader, e.Type, settings); // Should be equal if (!val.Equals(e.GetValue(ret))) { // If a readonly property or field is not the same, throw and exception ! throw new FormatException(e.Name); } break; } } } } if (ret is IBinaryVerifiable v && !v.Verify()) { throw new FormatException(); } return(ret); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { writer.Write((double)value); return(8); }
/// <summary> /// Deserialize logic /// </summary> /// <param name="deserializer">Deserializer</param> /// <param name="reader">Reader</param> /// <param name="settings">Settings</param> /// <returns>How many bytes have been written</returns> protected virtual void DeserializeExclusiveData(IBinarySerializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null) { }
public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null) { var l = (int)reader.ReadVarInt(ushort.MaxValue); if (l > MaxLength) { throw new FormatException(nameof(MaxLength)); } var a = (Array)Activator.CreateInstance(_type, l); for (var ix = 0; ix < l; ix++) { a.SetValue(_serializer.Deserialize(deserializer, reader, _itemType, settings), ix); } return(a); }
public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null) { var ar = (IEnumerable)value; if (ar == null) { return(writer.WriteVarInt(0)); } var x = writer.WriteVarInt((int)_countMethod.GetValue(value)); if (x > MaxLength) { throw new FormatException(nameof(MaxLength)); } foreach (var o in ar) { x += _serializer.Serialize(serializer, writer, o, settings); } return(x); }