public Slice ToSlice()
{
var writer = new TupleWriter();
PackTo(ref writer);
return(writer.Output.ToSlice());
}
internal void PackTo(ref TupleWriter writer)
{
foreach (var slice in m_slices.Span)
{
writer.Output.WriteBytes(slice);
}
}
/// <summary>Serialize a value of type <typeparamref name="T"/> into a tuple segment</summary>
/// <param name="value">Value that will be serialized</param>
/// <returns>Slice that contains the binary representation of <paramref name="value"/></returns>
public static Slice Serialize(T value)
{
var writer = new TupleWriter();
Encoder(ref writer, value);
return(writer.Output.ToSlice());
}
public override void EncodeOrderedSelfTerm(ref SliceWriter output, T value)
{
//HACKHACK: we lose the current depth!
var writer = new TupleWriter(output);
TuplePackers.SerializeTo(ref writer, value);
output = writer.Output;
}
public void EncodeKey <T1>(ref SliceWriter writer, T1 item1)
{
var tw = new TupleWriter(writer);
TuplePacker <T1> .SerializeTo(ref tw, item1);
writer = tw.Output;
}
public void PackKey <TTuple>(ref SliceWriter writer, TTuple items)
where TTuple : IVarTuple
{
var tw = new TupleWriter(writer);
TupleEncoder.WriteTo(ref tw, items);
writer = tw.Output;
}
/// <summary>Serialize a <typeparamref name="T"/> into a binary buffer</summary>
/// <param name="writer">Target buffer</param>
/// <param name="value">Value that will be serialized</param>
/// <remarks>
/// The buffer does not need to be preallocated.
/// This method DOES NOT support embedded tupels, and assumes that we are serializing a top-level Tuple!
/// If you need support for embedded tuples, use <see cref="SerializeTo(ref TupleWriter,T)"/> instead!
/// </remarks>
public static void SerializeTo(ref SliceWriter writer, T value)
{
var tw = new TupleWriter(writer);
Encoder(ref tw, value);
writer = tw.Output;
//REVIEW: we loose the depth information here! :(
}
internal void PackTo(ref TupleWriter writer)
{
var slices = m_slices;
int offset = m_offset;
int count = m_count;
for (int i = 0; i < count; i++)
{
writer.Output.WriteBytes(in slices[i + offset]);
}
}
public void EncodeKey <T1, T2, T3>(ref SliceWriter writer, T1 item1, T2 item2, T3 item3)
{
var tw = new TupleWriter(writer);
TuplePacker <T1> .SerializeTo(ref tw, item1);
TuplePacker <T2> .SerializeTo(ref tw, item2);
TuplePacker <T3> .SerializeTo(ref tw, item3);
writer = tw.Output;
}
public void EncodeKey <T1, T2, T3, T4, T5, T6>(ref SliceWriter writer, T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
{
var tw = new TupleWriter(writer);
TuplePacker <T1> .SerializeTo(ref tw, item1);
TuplePacker <T2> .SerializeTo(ref tw, item2);
TuplePacker <T3> .SerializeTo(ref tw, item3);
TuplePacker <T4> .SerializeTo(ref tw, item4);
TuplePacker <T5> .SerializeTo(ref tw, item5);
TuplePacker <T6> .SerializeTo(ref tw, item6);
writer = tw.Output;
}
internal void PackTo(ref TupleWriter writer)
{
writer.Output.WriteBytes(m_prefix);
TupleEncoder.WriteTo(ref writer, m_items);
}
void ITupleSerializable.PackTo(ref TupleWriter writer)
{
PackTo(ref writer);
}
public static void SerializeBoxedTo(ref TupleWriter writer, object value)
{
Encoder(ref writer, (T)value);
}
public static void SerializeTo(ref TupleWriter writer, T value)
{
Encoder(ref writer, value);
}
public void PackTo(ref TupleWriter writer, in STuple <T1> tuple)
