protected override byte[] OnConvertToBytes(IList list, IMarshalingProvider pool)
{
var c = pool.Construct();
var type = list.GetType();
if (type.IsGenericType)
{
var generic = type.GetGenericArguments()[0]; // <TYPE>
var typeDef = type.GetGenericTypeDefinition(); // IList<>
c.Attach <byte>(2);
c.Attach(generic);
c.Attach(typeDef);
c.Attach(list.Count);
foreach (var item in list)
{
c.Attach(generic, item);
}
}
else // IList<object>
{
var typeWithoutGeneric = type;
c.Attach <byte>(1);
c.Attach(type);
c.Attach(list.Count);
foreach (object item in list)
{
c.Attach(item);
}
}
return(c);
}
protected override byte[] OnConvertToBytes(DataTable table, IMarshalingProvider pool)
{
var c = pool.Construct();
c.Attach(table.TableName);
c.Attach(table.Namespace);
var columns = table.Columns.Cast <DataColumn>().ToArray();
c.Attach(columns);
var rows = table.Rows.Cast <DataRow>().ToArray();
c.Attach(rows.Length);
foreach (var row in rows)
{
foreach (var col in columns)
{
var item = row[col];
c.Attach(col.DataType, item);
}
}
return(c);
}
protected override byte[] OnConvertToBytes(object graph, IMarshalingProvider pool)
{
var type = graph.GetType();
byte[] result = pool.Construct().Attach(type).Attach(type, graph);
return(result);
}
protected override Array OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var element = d.Detach <Type>();
var count = d.Detach <int>(out length);
var array = Array.CreateInstance(element, count);
if (count == 0)
{
goto Leave;
}
if (count != 1)
{
for (int i = 0; i < count - 1; i++)
{
var current = d.Detach(element);
array.SetValue(current, i);
}
}
var last = d.Detach(element, out length);
array.SetValue(last, count - 1);
Leave:
return(array);
}
protected override byte[] OnConvertToBytes(IDictionary dict, IMarshalingProvider pool)
{
var type = dict.GetType();
var c = pool.Construct();
if (type.IsGenericType && s_dictTypes.Contains(type.GetGenericTypeDefinition()))
{
c.Attach <byte>(2); // Strong Type Convertion
c.Attach(dict.Count);
var ga = type.GetGenericArguments();
var keyType = ga[0];
var valyeType = ga[1];
c.Attach(keyType);
c.Attach(valyeType);
foreach (DictionaryEntry entry in dict)
{
c.Attach(keyType, entry.Key);
c.Attach(valyeType, entry.Value);
}
}
else
{
c.Attach <byte>(1); // Weak Type Convertion
c.Attach(dict.Count);
c.Attach(type);
foreach (DictionaryEntry entry in dict)
{
c.Attach(entry.Key);
c.Attach(entry.Value);
}
}
return(c);
}
protected override object OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var type = d.Detach <Type>();
var value = d.Detach(type, out length);
return(value);
}
protected override byte[] OnConvertToBytes(DataSet dataSet, IMarshalingProvider pool)
{
var c = pool.Construct();
c.Attach(dataSet.DataSetName);
var tables = dataSet.Tables.Cast <DataTable>().ToArray();
return(c.Attach(tables));
}
protected override Enum OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var enumType = d.Detach <Type>();
var underlyType = Enum.GetUnderlyingType(enumType);
var value = d.Detach(underlyType, out length);
return((Enum)Enum.ToObject(enumType, value));
}
protected override Test OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var obj = new Test();
obj.Data1 = d.Detach <int>();
obj.Data2 = d.Detach <string>(out length);
return(obj);
}
protected override IList OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var flag = d.Detach <byte>();
if (flag == 2)
{
var generic = d.Detach <Type>();
var typeDef = d.Detach <Type>();
var count = d.Detach <int>(out length);
var listType = typeDef.MakeGenericType(generic);
var list = (IList)Activator.CreateInstance(listType);
if (count == 0)
{
goto Leave;
}
if (count != 1)
{
for (int i = 0; i < count - 1; i++)
{
list.Add(d.Detach(generic));
}
}
list.Add(d.Detach(generic, out length));
Leave:
return(list);
}
else if (flag == 1)
{
var listType = d.Detach <Type>();
var count = d.Detach <int>(out length);
var list = (IList)Activator.CreateInstance(listType);
if (count == 0)
{
goto Leave;
}
if (count != 1)
{
for (int i = 0; i < count - 1; i++)
{
list.Add(d.Detach <object>());
}
}
list.Add(d.Detach <object>(out length));
Leave:
return(list);
}
throw new NotSupportedException();
}
protected override byte[] OnConvertToBytes(Enum graph, IMarshalingProvider pool)
{
var type = graph.GetType();
var underlyingType = Enum.GetUnderlyingType(type);
var c = pool.Construct();
c.Attach(type);
c.Attach(underlyingType, graph);
return(c);
}
protected override Regex OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var options = (RegexOptions)d.Detach <short>();
var timeSpan = d.Detach <TimeSpan>();
var regex = d.Detach <string>(out length);
var regexObject = new Regex(regex, options, timeSpan);
return(regexObject);
}
protected override DataSet OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var dataSetName = d.Detach <string>();
var dataSet = new DataSet(dataSetName);
var tables = d.Detach <DataTable[]>(out length);
dataSet.Tables.AddRange(tables);
return(dataSet);
}
protected override byte[] OnConvertToBytes(ITuple graph, IMarshalingProvider pool)
{
var c = pool.Construct();
c.Attach(graph.Length);
for (int i = 0; i < graph.Length; i++)
{
var current = graph[i];
c.Attach(current);
}
return(c);
}
protected override byte[] OnConvertToBytes(string graph, IMarshalingProvider pool)
{
if (string.Equals(graph, string.Empty))
{
return(_empty);
}
var value = Encoding.Unicode.GetBytes(graph);
var result = ConcatLenAndPayload(value);
return(result);
}
protected override byte[] OnConvertToBytes(BigInteger graph, IMarshalingProvider pool)
{
var bi = graph.ToByteArray();
var c = pool.Construct();
c.Attach(bi.Length);
for (int i = 0; i < bi.Length; i++)
{
c.Attach(bi[i]);
}
return(c);
}
public T FromBytes(byte[] bytes, out int spanLength, IMarshalingProvider pool)
{
spanLength = 0;
if (bytes == null || bytes.Length == 0)
{
throw new ArgumentNullException(nameof(bytes));
}
if (IsDefaultValueBytes(bytes))
{
spanLength = DefaultValueBytes.Length;
return(default);
protected override byte[] OnConvertToBytes(Array list, IMarshalingProvider pool)
{
var c = pool.Construct();
var elementType = list.GetType().GetElementType();
c.Attach(elementType);
c.Attach(list.Length);
for (int i = 0; i < list.Length; i++)
{
c.Attach(elementType, list.GetValue(i));
}
return(c);
}
protected override byte[] OnConvertToBytes(Type graph, IMarshalingProvider pool)
{
var c = pool.Construct();
if (TypeMap.TryGet(graph.AssemblyQualifiedName, out var code))
{
c.Attach(code);
}
else
{
c.Attach(0x7FFFFFFF).Attach(graph.AssemblyQualifiedName);
}
return(c);
}
public void Init()
{
p = Marshallers.Common;
table = new DataTable("Test");
table.Columns.Add("Test1");
table.Columns.Add("Test2");
for (int i = 0; i < 10; i++)
{
var row = table.NewRow();
row[0] = i;
row[1] = 1 << i;
table.Rows.Add(row);
}
}
protected override string OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var span = bytes.AsSpan();
if (span.Length == _empty.Length && _empty.AsSpan().SequenceEqual(span.Slice(0, _empty.Length)))
{
length = _empty.Length;
return(string.Empty);
}
var payload = SeparateLenAndPayload(bytes, out length);
var result = Encoding.Unicode.GetString(payload);
return(result);
}
protected override Type OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var code = d.Detach <int>(out length);
if (TypeMap.TryGet(code, out var typeString))
{
return(Type.GetType(typeString));
}
if (code == 0x7FFFFFFF)
{
return(Type.GetType(d.Detach <string>(out length)));
}
throw new InvalidCastException("Dislocation, unregistered type or not type not matched.");
}
protected override byte[] OnConvertToBytes(TSelf graph, IMarshalingProvider pool)
{
var c = pool.Construct();
foreach (var carried in _carrieds)
{
var getter = carried.GetValue(graph);
c.Attach(getter.GetType(), getter);
}
byte[] bytes = c;
for (int i = 0; i < s_pipes.Count; i++)
{
bytes = s_pipes[i].Inflow(bytes);
}
return(bytes);
}
protected override ITuple OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var maxStackSize = d.Detach <int>();
var values = new Stack <object>(maxStackSize);
for (int i = 0; i < maxStackSize - 1; i++)
{
var current = d.Detach <object>();
values.Push(current);
}
var last = d.Detach <object>(out length);
values.Push(last);
return(CreateByArgs(values, maxStackSize));
}
protected override byte[] OnConvertToBytes(DataColumn column, IMarshalingProvider pool)
{
var c = pool.Construct()
.Attach(column.ColumnName)
.Attach(column.DataType)
.Attach(column.Expression)
.Attach((byte)column.ColumnMapping)
.Attach(column.AllowDBNull)
.Attach(column.AutoIncrement)
.Attach(column.AutoIncrementSeed)
.Attach(column.AutoIncrementStep)
.Attach(column.Caption)
.Attach((byte)column.DateTimeMode)
.Attach(column.MaxLength)
.Attach(column.Namespace)
.Attach(column.ReadOnly)
.Attach(column.Unique);
return(c);
}
protected override byte[] OnConvertToBytes(byte graph, IMarshalingProvider pool) => new byte[1]
{
graph
};
protected override byte OnConvertFromBytes(byte[] bytes, IMarshalingProvider pool) => bytes[0];
protected override BigInteger OnConvertFromBytes(byte[] bytes, out int length, IMarshalingProvider pool)
{
var d = pool.Deconstruct(bytes);
var len = d.Detach <int>(out length);
var array = new byte[len];
if (len == 0)
{
goto Leave;
}
if (len != 1)
{
for (int i = 0; i < len - 1; i++)
{
array[i] = d.Detach <byte>();
}
}
array[len - 1] = d.Detach <byte>(out length);
Leave:
return(new BigInteger(array));
}
protected override byte[] OnConvertToBytes(Guid graph, IMarshalingProvider pool) => graph.ToByteArray();
protected override Guid OnConvertFromBytes(byte[] bytes, IMarshalingProvider pool) => new Guid(bytes.AsSpan(0, SpanSize).ToArray());
