Add bascic support for VersionStamps to Tuple Encoder

- Support both 80-bits and 96-bits variants
- BUGBUG: cannot recognized complete/incomplete stamps yet when parsing.

Author: KrzysFR

FoundationDB.Client/Layers/Tuples/Encoding/TuplePackers.cs

@@ -40,6 +40,7 @@ namespace Doxense.Collections.Tuples.Encoding
 	using Doxense.Collections.Tuples;
 	using Doxense.Diagnostics.Contracts;
 	using Doxense.Runtime.Converters;
+	using FoundationDB.Client;
 	using JetBrains.Annotations;
 
 	/// <summary>Helper methods used during serialization of values to the tuple binary format</summary>
@@ -553,6 +554,11 @@ public static void SerializeTo(ref TupleWriter writer, Uuid64 value)
 			TupleParser.WriteUuid64(ref writer, value);
 		}
 
+		public static void SerializeTo(ref TupleWriter writer, VersionStamp value)
+		{
+			TupleParser.WriteVersionStamp(ref writer, value);
+		}
+
 		/// <summary>Writes an IPaddress as a 32-bit (IPv4) or 128-bit (IPv6) byte array</summary>
 		public static void SerializeTo(ref TupleWriter writer, System.Net.IPAddress value)
 		{
@@ -680,6 +686,7 @@ private static Dictionary<Type, Delegate> InitializeDefaultUnpackers()
 				[typeof(TimeSpan)] = new Func<Slice, TimeSpan>(TuplePackers.DeserializeTimeSpan),
 				[typeof(DateTime)] = new Func<Slice, DateTime>(TuplePackers.DeserializeDateTime),
 				[typeof(System.Net.IPAddress)] = new Func<Slice, System.Net.IPAddress>(TuplePackers.DeserializeIPAddress),
+				[typeof(VersionStamp)] = new Func<Slice, VersionStamp>(TuplePackers.DeserializeVersionStamp),
 				[typeof(ITuple)] = new Func<Slice, ITuple>(TuplePackers.DeserializeTuple),
 			};
 
@@ -1694,6 +1701,24 @@ public static Uuid64 DeserializeUuid64(Slice slice)
 			throw new FormatException($"Cannot convert tuple segment of type 0x{type:X} into an Uuid64");
 		}
 
+		public static VersionStamp DeserializeVersionStamp(Slice slice)
+		{
+			if (slice.IsNullOrEmpty) return default(VersionStamp);
+
+			int type = slice[0];
+
+			if (type == TupleTypes.VersionStamp80 || type == TupleTypes.VersionStamp96)
+			{
+				if (VersionStamp.TryParse(slice.Substring(1), out var stamp))
+				{
+					return stamp;
+				}
+				throw new FormatException("Cannot convert malformed tuple segment into a VersionStamp");
+			}
+
+			throw new FormatException($"Cannot convert tuple segment of type 0x{type:X} into a VersionStamp");
+		}
+
 		/// <summary>Deserialize a tuple segment into Guid</summary>
 		/// <param name="slice">Slice that contains a single packed element</param>
 		[CanBeNull]

FoundationDB.Client/Layers/Tuples/Encoding/TupleParser.cs

@@ -34,6 +34,7 @@ namespace Doxense.Collections.Tuples.Encoding
 	using Doxense.Collections.Tuples;
 	using Doxense.Diagnostics.Contracts;
 	using Doxense.Memory;
+	using FoundationDB.Client;
 	using JetBrains.Annotations;
 
 	/// <summary>Helper class that contains low-level encoders for the tuple binary format</summary>
@@ -758,6 +759,28 @@ public static void WriteUuid64(ref TupleWriter writer, Uuid64? value)
 			if (!value.HasValue) WriteNil(ref writer); else WriteUuid64(ref writer, value.Value);
 		}
 
+		public static void WriteVersionStamp(ref TupleWriter writer, VersionStamp value)
+		{
+			if (value.HasUserVersion)
+			{ // 96-bits Versionstamp
+				writer.Output.EnsureBytes(13);
+				writer.Output.UnsafeWriteByte(TupleTypes.VersionStamp96);
+				value.WriteTo(writer.Output.Allocate(12));
+			}
+			else
+			{ // 80-bits Versionstamp
+				writer.Output.EnsureBytes(11);
+				writer.Output.UnsafeWriteByte(TupleTypes.VersionStamp80);
+				value.WriteTo(writer.Output.Allocate(10));
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static void WriteVersionStamp(ref TupleWriter writer, VersionStamp? value)
+		{
+			if (!value.HasValue) WriteNil(ref writer); else WriteVersionStamp(ref writer, value.Value);
+		}
+
 		/// <summary>Mark the start of a new embedded tuple</summary>
 		public static void BeginTuple(ref TupleWriter writer)
 		{
@@ -1096,6 +1119,16 @@ public static Slice ParseNext(ref TupleReader reader)
 					return reader.Input.ReadBytes(9);
 				}
 
+				case TupleTypes.VersionStamp80:
+				{ // <32>(10 bytes)
+					return reader.Input.ReadBytes(11);
+				}
+
+				case TupleTypes.VersionStamp96:
+				{ // <33>(12 bytes)
+					return reader.Input.ReadBytes(13);
+				}
+
 				case TupleTypes.AliasDirectory:
 				case TupleTypes.AliasSystem:
 				{ // <FE> or <FF>

FoundationDB.Client/Layers/Tuples/Encoding/TupleTypes.cs

@@ -86,6 +86,11 @@ internal static class TupleTypes
 		/// <summary>UUID (64 bits) [DRAFT]</summary>
 		internal const byte Uuid64 = 49; //TODO: this is not official yet! may change!
 
+		//TODO: xmldoc
+		internal const byte VersionStamp80 = 0x32;
+		//TODO: xmldoc
+		internal const byte VersionStamp96 = 0x33;
+
 		/// <summary>Standard prefix of the Directory Layer</summary>
 		/// <remarks>This is not a part of the tuple encoding itself, but helps the tuple decoder pretty-print tuples that would otherwise be unparsable.</remarks>
 		internal const byte AliasDirectory = 254;
@@ -112,6 +117,8 @@ public static TupleSegmentType DecodeSegmentType(Slice segment)
 				case Decimal: return TupleSegmentType.Decimal;
 				case Uuid128: return TupleSegmentType.Uuid128;
 				case Uuid64: return TupleSegmentType.Uuid64;
+				case VersionStamp80: return TupleSegmentType.VersionStamp80;
+				case VersionStamp96: return TupleSegmentType.VersionStamp96;
 			}
 
 			if (type <= IntPos8 && type >= IntNeg8)
@@ -138,6 +145,8 @@ public enum TupleSegmentType
 		Decimal = 35,
 		Uuid128 = 48,
 		Uuid64 = 49,
+		VersionStamp80 = 0x32,
+		VersionStamp96 = 0x33,
 	}
 
 }