public static string ToHex(this ISerializedType st)
{
BytesList list = new BytesList();
st.ToBytes(list);
return(list.BytesHex());
}
public static string ToDebuggedHex(this ISerializedType st)
{
BytesList list = new BytesList();
st.ToBytes(list);
return(list.RawList().Aggregate("", (a, b) = \ > \ a + ',' + B16.Encode(b)));
}
public void AddLengthEncoded(ISerializedType value)
{
var bytes = new BytesList();
value.ToBytes(bytes);
AddLengthEncoded(bytes);
}
public SimpleSerializedObject(T data, Type dataType, ISerializedType serializedType)
{
Assert.NotNull(data, () => "Data for a serialized object cannot be null");
Assert.NotNull(serializedType, () => "The type identifier of the serialized object");
_data = data;
_dataType = dataType;
_type = serializedType;
}
public static void Serialize(Serializer so, string fieldName, object value)
{
var fieldCoordinates = InverseFieldsMap[fieldName];
var typeBits = fieldCoordinates.Key;
var fieldBits = fieldCoordinates.Value;
var tagByte = (typeBits < 16 ? typeBits << 4 : 0) | (fieldBits < 16 ? fieldBits : 0);
if (value is string str)
{
if (fieldName == "LedgerEntryType")
{
value = (int)Enum.Parse(typeof(LedgerEntryType), str);
}
else if (fieldName == "TransactionResult")
{
value = (int)Enum.Parse(typeof(TransactionType), str);
}
}
STInt8.Serialize(so, (byte)tagByte);
if (typeBits >= 16)
{
STInt8.Serialize(so, (byte)typeBits);
}
if (fieldBits >= 16)
{
STInt8.Serialize(so, (byte)fieldBits);
}
ISerializedType serializedType = null;
if (fieldName == "Memo" && value is MemoDataInfo)
{
serializedType = STMemo;
}
else if (fieldName == "Arg" && value is ParameterInfo)
{
serializedType = STArg;
}
else
{
serializedType = _typesMap[typeBits];
}
try
{
serializedType.Serialize(so, value);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Field with name '{fieldName}' cannot be serialized.", ex);
}
}
public override JObject ToJObject(StObject obj)
{
var json = new JObject();
foreach (Field f in obj)
{
try
{
ISerializedType obj1 = obj[f];
Object someObject = obj1.ToJson();
if (someObject is JToken)
{
if (FieldSymbolics.IsSymbolicField(f) && ((JToken)someObject).Type == JTokenType.Integer)
{
someObject = FieldSymbolics.AsString(f, ((JToken)someObject).ToObject <int>());
}
json.Add(Field.GetName(f), (JToken)someObject);
}
else if (FieldSymbolics.IsSymbolicField(f) && someObject is int)
{
someObject = FieldSymbolics.AsString(f, (int)someObject);
json.Add(Field.GetName(f), someObject.ToString());
}
else if (someObject is int)
{
json.Add(Field.GetName(f), (int)someObject);
}
else
{
json.Add(Field.GetName(f), someObject.ToString());
}
}
catch (JsonException e)
{
throw new ApplicationException("Json serialization failed.", e);
}
}
return(json);
}
public void Add(Field field, ISerializedType value)
{
AddFieldHeader(field);
if (field.IsVlEncoded)
{
AddLengthEncoded(value);
}
else
{
value.ToBytes(_sink);
if (field.Type == FieldType.StObject)
{
AddFieldHeader(Field.ObjectEndMarker);
}
else if (field.Type == FieldType.StArray)
{
AddFieldHeader(Field.ArrayEndMarker);
}
}
}
public void Add(Field f, ISerializedType value)
{
fields.Add(f, value);
}
public void Write(ISerializedType obj)
{
obj.ToBytesSink(_list);
}
public void Add(Field field, ISerializedType value)
{
AddFieldHeader(field);
if (field.IsVlEncoded)
{
AddLengthEncoded(value);
}
else
{
value.ToBytes(_sink);
if (field.Type == FieldType.StObject)
{
AddFieldHeader(Field.ObjectEndMarker);
}
else if (field.Type == FieldType.StArray)
{
AddFieldHeader(Field.ArrayEndMarker);
}
}
}
public void AddLengthEncoded(ISerializedType value)
{
var bytes = new BytesList();
value.ToBytes(bytes);
AddLengthEncoded(bytes);
}
public Type ClassForType(ISerializedType obj)
{
return(_serializer.ClassForType(obj));
}
public SimpleSerializedObject(T data, ISerializedType serializedType)
{
Data = data;
ContentType = typeof(T);
Type = serializedType;
}
