/// <summary>
/// Deserialize
/// </summary>
/// <param name="deserializer">Deserializer</param>
/// <param name="br">Stream</param>
/// <returns>Return object</returns>
public object Deserialize(IBinaryDeserializer deserializer, BinaryReader br)
{
object ret = Activator.CreateInstance(Type);
Deserialize(deserializer, br, ret);
return(ret);
}
public static Command Deserialize(IBinaryDeserializer binaryDeserializer)
{
var name = binaryDeserializer.ReadString();
var admins = binaryDeserializer.DeserializeCollection(() => new ConcurrentSet <string>(), binaryDeserializer.ReadString);
return(new Command(name, admins));
}
protected override void DeserializeExclusiveData(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null)
{
if (Version > 1)
{
throw new FormatException(nameof(Version));
}
Script = reader.ReadVarBytes(65536);
if (Script.Length == 0)
{
throw new FormatException();
}
if (Version >= 1)
{
Gas = deserializer.Deserialize <Fixed8>(reader, settings);
if (Gas < Fixed8.Zero)
{
throw new FormatException();
}
}
else
{
Gas = Fixed8.Zero;
}
}
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 static AddCommandOperation Deserialize(IBinaryDeserializer binaryDeserializer)
{
var commandName = binaryDeserializer.ReadString();
var executorId = binaryDeserializer.ReadString();
return(new AddCommandOperation(commandName, executorId));
}
public static AddExecutorOperation Deserialize(IBinaryDeserializer binaryDeserializer)
{
var executorId = binaryDeserializer.ReadString();
var apiKey = binaryDeserializer.ReadString();
return(new AddExecutorOperation(executorId, apiKey));
}
public static Executor Deserialize(IBinaryDeserializer binaryDeserializer)
{
var id = binaryDeserializer.ReadString();
var apiKey = binaryDeserializer.ReadString();
return(new Executor(id, apiKey));
}
public static AddCommandAdminOperation Deserialize(IBinaryDeserializer binaryDeserializer)
{
var commandName = binaryDeserializer.ReadString();
var apiKey = binaryDeserializer.ReadString();
return(new AddCommandAdminOperation(commandName, apiKey));
}
private static void InitializeBinarySerializer(
IBinarySerializer binarySerializer,
IBinaryDeserializer binaryDeserializer)
{
BinarySerializer.Initialize(binarySerializer);
BinaryDeserializer.Initialize(binaryDeserializer);
}
public StateTransactionProcessor(IRepository repository, IBinaryDeserializer deserializer,
IAccountManager accountManager)
{
_repository = repository;
_deserializer = deserializer;
_accountManager = accountManager;
}
public object Deserialize(IBinaryDeserializer binaryDeserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null)
{
var val = new byte[FixedLength];
reader.Read(val, 0, FixedLength);
return(new UInt160(val));
}
public static DataMessage Deserialize(IBinaryDeserializer deserializer, IConnectionUtility utility)
{
return(new DataMessage(
(DataAction)deserializer.ReadInt(),
deserializer.ReadString(),
deserializer.ReadBytes(),
utility.DeserializeAddress(deserializer)));
}
public static DataStorage Deserialize(IBinaryDeserializer deserializer)
{
return(new DataStorage(deserializer.ReadList(d => new
{
Key = Encoding.UTF8.GetString(deserializer.ReadBytes()),
Value = deserializer.ReadBytes()
}).ToDictionary(x => x.Key, x => x.Value)));
}
protected override void DeserializeExclusiveData(IBinaryDeserializer deserializer, BinaryReader reader, BinarySerializerSettings settings = null)
{
AssetType = (AssetType)reader.ReadByte();
Name = reader.ReadVarString(1024);
Amount = deserializer.Deserialize <Fixed8>(reader, settings);
Precision = reader.ReadByte();
Owner = deserializer.Deserialize <ECPoint>(reader, settings);
Admin = deserializer.Deserialize <UInt160>(reader, settings);
}
public RedisDbBinaryRepository(
IRedisDbContext redisDbContext,
IBinarySerializer binarySerializer,
IBinaryDeserializer binaryDeserializer)
{
_redisDbContext = redisDbContext ?? throw new ArgumentNullException(nameof(redisDbContext));
_binarySerializer = binarySerializer ?? throw new ArgumentNullException(nameof(binarySerializer));
_binaryDeserializer = binaryDeserializer ?? throw new ArgumentNullException(nameof(binaryDeserializer));
}
public object Deserialize(IBinaryDeserializer 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 static List <T> ReadList <T>(this IBinaryDeserializer deserializer, Func <IBinaryDeserializer, T> readFunc)
{
var count = deserializer.ReadInt();
var list = new List <T>(count);
for (int i = 0; i < count; i++)
{
list.Add(deserializer.Read(readFunc));
}
return(list);
}
public RocksDbRepository
(
IRocksDbContext rocksDbContext,
IBinarySerializer binarySerializer,
IBinaryDeserializer binaryDeserializer
)
{
_rocksDbContext = rocksDbContext ?? throw new ArgumentNullException(nameof(rocksDbContext));
_binarySerializer = binarySerializer ?? throw new ArgumentNullException(nameof(binarySerializer));
_binaryDeserializer = binaryDeserializer;
}
public static TCollection DeserializeCollection <TValue, TCollection>(
this IBinaryDeserializer binaryDeserializer, Func <TCollection> collectionInitializer, Func <TValue> selector)
where TCollection : ICollection <TValue>
{
var count = binaryDeserializer.ReadInt32();
var array = collectionInitializer();
for (var i = 0; i < count; i++)
{
array.Add(selector());
}
return(array);
}
static Transformer()
{
_typeCreator = new TypeCreator();
_typeAnalyzer = new TypeAnalyzer();
_typeMapper = new EverythingTypeMapper(_typeAnalyzer);
_mappingRegistry = new MappingRegistry(_typeMapper);
_jsonSerializer = new JsonSerializer(_mappingRegistry);
_jsonDeserializer = new JsonDeserializer(_mappingRegistry, _typeCreator);
_binarySerializer = new BinarySerializer(_mappingRegistry);
_binaryDeserializer = new BinaryDeserializer(_mappingRegistry, _typeCreator);
_xmlSerializer = new XmlSerializer(_mappingRegistry);
_xmlDeserializer = new XmlDeserializer(_mappingRegistry, _typeCreator);
}
/// <summary>
/// Deserialize without create a new object
/// </summary>
/// <param name="deserializer">Deserializer</param>
/// <param name="br">Stream</param>
/// <param name="obj">Object</param>
public void Deserialize(IBinaryDeserializer deserializer, BinaryReader br, object obj)
{
foreach (BinarySerializerCacheEntry e in _entries)
{
if (e.ReadOnly)
{
// Consume it
e.ReadValue(deserializer, br);
continue;
}
e.SetValue(obj, e.ReadValue(deserializer, br));
}
}
/// <summary>
/// Deserialize logic
/// </summary>
/// <param name="deserializer">Deserializer</param>
/// <param name="reader">Reader</param>
/// <param name="settings">Settings</param>
public void Deserialize(IBinaryDeserializer 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));
}
}
}
public void Setup()
{
var typeCreator = new TypeCreator();
var typeAnalyzer = new TypeAnalyzer();
var typeMapper = new EverythingTypeMapper(typeAnalyzer);
var mappingRegistry = new MappingRegistry(typeMapper);
_binarySerializer = new BinarySerializer(mappingRegistry);
_binaryDeserializer = new BinaryDeserializer(mappingRegistry, typeCreator);
_jsonSerializer = new JsonSerializer(mappingRegistry);
_jsonDeserializer = new JsonDeserializer(mappingRegistry, typeCreator);
_xmlSerializer = new XmlSerializer(mappingRegistry);
_xmlDeserializer = new XmlDeserializer(mappingRegistry, typeCreator);
}
public static SerializableIndex <TKey, TValue> Deserialize <TKey, TValue>(IBinaryDeserializer binaryDeserializer,
Func <IBinaryDeserializer, TKey> keySelector,
Func <IBinaryDeserializer, TValue> valueSelector)
{
var index = new ConcurrentDictionary <TKey, TValue>();
var count = binaryDeserializer.ReadInt32();
for (var i = 0; i < count; i++)
{
var key = keySelector(binaryDeserializer);
var value = valueSelector(binaryDeserializer);
index[key] = value;
}
return(new SerializableIndex <TKey, TValue>(index));
}
public object Deserialize(IBinaryDeserializer 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 = (IList)Activator.CreateInstance(_type);
for (var ix = 0; ix < l; ix++)
{
a.Add(_serializer.Deserialize(deserializer, reader, _itemType, settings));
}
return(a);
}
public object GetArrayValue(IBinaryDeserializer deserializer, BinaryReader reader)
{
var l = (int)ReadVarInt(reader, ushort.MaxValue);
if (l > MaxLength)
{
throw new FormatException("MaxLength");
}
var a = (Array)Activator.CreateInstance(Type, l);
for (var ix = 0; ix < l; ix++)
{
a.SetValue(GetValue(deserializer, reader), ix);
}
return(a);
}
public object Deserialize(IBinaryDeserializer binaryDeserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null)
{
var data = reader.ReadBytes(16);
if (data.Length != 16)
{
throw new FormatException();
}
var address = new IPAddress(data);
data = reader.ReadBytes(2);
if (data.Length != 2)
{
throw new FormatException();
}
var port = data.Reverse().ToArray().ToUInt16(0);
return(new IPEndPoint(address, port));
}
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);
}
/// <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);
}
/// <summary>
/// Deserialize logic
/// </summary>
/// <param name="binaryDeserializer">Deserializer</param>
/// <param name="reader">Reader</param>
/// <param name="type">Type</param>
/// <param name="settings">Settigns</param>
/// <returns>Return object</returns>
public object Deserialize(IBinaryDeserializer binaryDeserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null)
{
byte[] data;
var usage = (TransactionAttributeUsage)reader.ReadByte();
if (usage == TransactionAttributeUsage.ContractHash || usage == TransactionAttributeUsage.Vote ||
(usage >= TransactionAttributeUsage.Hash1 && usage <= TransactionAttributeUsage.Hash15))
{
data = reader.ReadBytes(32);
}
else if (usage == TransactionAttributeUsage.ECDH02 || usage == TransactionAttributeUsage.ECDH03)
{
data = new[] { (byte)usage }.Concat(reader.ReadBytes(32)).ToArray();
}
else if (usage == TransactionAttributeUsage.Script)
{
data = reader.ReadBytes(20);
}
else if (usage == TransactionAttributeUsage.DescriptionUrl)
{
data = reader.ReadBytes(reader.ReadByte());
}
else if (usage == TransactionAttributeUsage.Description || usage >= TransactionAttributeUsage.Remark)
{
data = reader.ReadVarBytes(ushort.MaxValue);
}
else
{
throw new FormatException();
}
return(new TransactionAttribute()
{
Usage = usage,
Data = data
});
}
