public void ToBytes(IBytesSink sink)
{
foreach (var so in this)
{
so.ToBytes(sink);
}
}
public void ToBytes(IBytesSink sink)
{
var ser = new BinarySerializer(sink);
ser.AddLengthEncoded(Tx);
ser.AddLengthEncoded(Meta);
}
public void ToBytesSink(IBytesSink to)
{
int n = 0;
foreach (var path in this)
{
if (n++ != 0)
{
to.Add(PathSeparatorByte);
}
foreach (var hop in path)
{
int type = hop.Type;
to.Add((byte)type);
if (hop.Account != null)
{
to.Add(hop.Account.Bytes);
}
if (hop.Currency != null)
{
to.Add(hop.Currency.Bytes);
}
if (hop.Issuer != null)
{
to.Add(hop.Issuer.Bytes);
}
}
}
to.Add(PathsetEndByte);
}
public void ToBytes(IBytesSink buffer)
{
var n = 0;
foreach (var path in this)
{
if (n++ != 0)
{
buffer.Put(PathSeparatorByte);
}
foreach (var hop in path)
{
buffer.Put((byte)hop.Type);
if (hop.HasAccount())
{
buffer.Put(hop.Account.Buffer);
}
if (hop.HasCurrency())
{
buffer.Put(hop.Currency.Buffer);
}
if (hop.HasIssuer())
{
buffer.Put(hop.Issuer.Buffer);
}
}
}
buffer.Put(PathsetEndByte);
}
public void ToBytes(IBytesSink sink)
{
foreach (var hash in this)
{
hash.ToBytes(sink);
}
}
public void ToBytesSink(IBytesSink to)
{
foreach (var hash256 in this)
{
hash256.ToBytesSink(to);
}
}
public void ToBytesSink(IBytesSink to)
{
foreach (var stObject in this)
{
stObject.ToBytesSink(to);
}
}
public void ToBytesSink(IBytesSink to)
{
UInt64 man = Mantissa();
if (IsNative)
{
if (!IsNegative)
{
man = man.Or(BinaryFlagIsNonNegativeNative);
}
to.Add(man.ToByteArray());
}
else
{
int offset = Offset;
UInt64 packed;
if (IsZero)
{
packed = BinaryFlagIsIou;
}
else if (IsNegative)
{
packed = man.Or(new UInt64(((long)512 + 0 + 97 + offset)).ShiftLeft(64 - 10));
}
else
{
packed = man.Or(new UInt64(((long)512 + 256 + 97 + offset)).ShiftLeft(64 - 10));
}
to.Add(packed.ToByteArray());
to.Add(_currency.Bytes);
to.Add(_issuer.Bytes);
}
}
public void ToBytes(IBytesSink sink)
{
sink.Put(Value.ToBytes());
if (!IsNative)
{
Currency.ToBytes(sink);
Issuer.ToBytes(sink);
}
}
public void ToBytes(IBytesSink sink)
{
sink.Put(Value.ToBytes());
if (!IsNative)
{
Currency.ToBytes(sink);
Issuer.ToBytes(sink);
}
}
public void ToBytes(IBytesSink to, Func \ \ p)
{
var serializer = new BinarySerializer(to);
foreach (var pair in Fields.Where(pair = \ > \ pair.Key.IsSerialised &&
(p == null || p(pair.Key))))
{
serializer.Add(pair.Key, pair.Value);
}
}
private void ToBytes(IBytesSink sink)
{
LedgerIndex.ToBytes(sink);
TotalDrops.ToBytes(sink);
ParentHash.ToBytes(sink);
TransactionHash.ToBytes(sink);
StateHash.ToBytes(sink);
ParentCloseTime.ToBytes(sink);
CloseTime.ToBytes(sink);
CloseResolution.ToBytes(sink);
CloseFlags.ToBytes(sink);
}
private void ToBytes(IBytesSink sink)
{
LedgerIndex.ToBytes(sink);
TotalDrops.ToBytes(sink);
ParentHash.ToBytes(sink);
TransactionHash.ToBytes(sink);
StateHash.ToBytes(sink);
ParentCloseTime.ToBytes(sink);
CloseTime.ToBytes(sink);
CloseResolution.ToBytes(sink);
CloseFlags.ToBytes(sink);
}
public void ToBytesSink(IBytesSink to, IFieldFilter p)
{
var serializer = new BinarySerializer(to);
foreach (var field in this)
{
if (p.Evaluate(field))
{
var value = fields[field];
serializer.Add(field, value);
}
}
}
public override void ToBytesSink(IBytesSink sink)
{
foreach (var branch in Branches)
{
if (branch != null)
{
branch.Hash().ToBytes(sink);
}
else
{
Hash256.Zero.ToBytes(sink);
}
}
}
public void ToBytes(IBytesSink sink)
{
sink.Put(Bytes);
}
public void ToBytesSink(IBytesSink to)
{
ToBytesSink(to, new IsSerializedFieldFilter());
}
public override void ToBytesSink(VariableLength obj, IBytesSink to)
{
to.Add(obj._buffer);
}
public void ToBytes(IBytesSink sink) = \ > \ sink.Put(ToBytes());
public abstract void ToBytesSink(IBytesSink sink);
public void ToBytes(IBytesSink sink)
{
Entry.ToBytes(sink);
}
public override void ToBytesSink(T obj, IBytesSink to)
{
to.Add(obj.ToByteArray());
}
public virtual void ToBytesSink(TIn obj, IBytesSink to)
{
obj.ToBytesSink(to);
}
public void ToBytes(IBytesSink to)
{
ToBytes(to, null);
}
public BinarySerializer(IBytesSink sink)
{
_sink = sink;
}
public override void ToBytesSink(T obj, IBytesSink to)
{
to.Add(obj.HashBytes);
}
public void ToBytes(IBytesSink to, Func<Field, bool> p)
{
var serializer = new BinarySerializer(to);
foreach (var pair in Fields.Where(pair => pair.Key.IsSerialised &&
(p == null || p(pair.Key))))
{
serializer.Add(pair.Key, pair.Value);
}
}
public override void ToBytesSink(IBytesSink sink)
{
Item.ToBytes(sink);
Index.ToBytes(sink);
}
public void ToBytes(IBytesSink sink)
{
sink.Put(Buffer);
}
public void ToBytes(IBytesSink to)
{
ToBytes(to, null);
}
public BinarySerializer(IBytesSink sink)
{
_sink = sink;
}
public override void ToBytesSink(IBytesSink sink)
{
foreach (var branch in Branches)
{
if (branch != null)
{
branch.Hash().ToBytes(sink);
}
else
{
Hash256.Zero.ToBytes(sink);
}
}
}
public abstract void ToBytesSink(IBytesSink sink);
public override void ToBytesSink(IBytesSink sink)
{
Item.ToBytes(sink);
Index.ToBytes(sink);
}
public override void ToBytesSink(IBytesSink to)
{
InTranslate.ToBytesSink(this, to);
}
public void ToBytes(IBytesSink sink)
{
sink.Put(Buffer);
}
public void ToBytesSink(IBytesSink to)
{
to.Add(Bytes);
}
public abstract void ToBytesSink(IBytesSink to);
