/// <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);
}