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)