public void Serialize(NetDataWriter writer, T[,,] value, NetDataSerializerOptions options)
{
if (value == null)
{
writer.Write(false);
}
else
{
writer.Write(true);
var i = value.GetLength(0);
var j = value.GetLength(1);
var k = value.GetLength(2);
INetDataFormatter <T> formatter = options.Resolver.GetFormatter <T>();
writer.Write(ArrayLength);
writer.Write(i);
writer.Write(j);
writer.Write(k);
writer.Write((int)value.Length);
foreach (T item in value)
{
formatter.Serialize(writer, item, options);
}
}
}
public TDictionary Deserialize(NetDataReader reader, NetDataSerializerOptions options)
{
if (reader.ReadBoolean() == false)
{
return(default(TDictionary));
}
else
{
INetDataFormatterResolver resolver = options.Resolver;
INetDataFormatter <TKey> keyFormatter = resolver.GetFormatter <TKey>();
INetDataFormatter <TValue> valueFormatter = resolver.GetFormatter <TValue>();
var len = reader.ReadInt32();
TIntermediate dict = this.Create(len, options);
for (int i = 0; i < len; i++)
{
TKey key = keyFormatter.Deserialize(reader, options);
TValue value = valueFormatter.Deserialize(reader, options);
this.Add(dict, i, key, value, options);
}
return(this.Complete(dict));
}
}
public T[,,,] Deserialize(NetDataReader reader, NetDataSerializerOptions options)
{
if (reader.ReadBoolean() == false)
{
return(null);
}
else
{
INetDataFormatter <T> formatter = options.Resolver.GetFormatter <T>();
var len = reader.ReadByte();
if (len != ArrayLength)
{
throw new NetDataSerializationException("Invalid T[,,,] format");
}
var iLength = reader.ReadInt32();
var jLength = reader.ReadInt32();
var kLength = reader.ReadInt32();
var lLength = reader.ReadInt32();
var maxLen = reader.ReadInt32();
var array = new T[iLength, jLength, kLength, lLength];
var i = 0;
var j = 0;
var k = 0;
var l = -1;
for (int loop = 0; loop < maxLen; loop++)
{
if (l < lLength - 1)
{
l++;
}
else if (k < kLength - 1)
{
l = 0;
k++;
}
else if (j < jLength - 1)
{
l = 0;
k = 0;
j++;
}
else
{
l = 0;
k = 0;
j = 0;
i++;
}
array[i, j, k, l] = formatter.Deserialize(reader, options);
}
return(array);
}
}
public void Serialize(NetDataWriter writer, TDictionary value, NetDataSerializerOptions options)
{
if (value == null)
{
writer.Write(false);
}
else
{
writer.Write(true);
INetDataFormatterResolver resolver = options.Resolver;
INetDataFormatter <TKey> keyFormatter = resolver.GetFormatter <TKey>();
INetDataFormatter <TValue> valueFormatter = resolver.GetFormatter <TValue>();
int count;
{
var col = value as ICollection <KeyValuePair <TKey, TValue> >;
if (col != null)
{
count = col.Count;
}
else
{
var col2 = value as IReadOnlyCollection <KeyValuePair <TKey, TValue> >;
if (col2 != null)
{
count = col2.Count;
}
else
{
throw new NetDataSerializationException("DictionaryFormatterBase's TDictionary supports only ICollection<KVP> or IReadOnlyCollection<KVP>");
}
}
}
writer.Write(count);
TEnumerator e = this.GetSourceEnumerator(value);
try
{
while (e.MoveNext())
{
KeyValuePair <TKey, TValue> item = e.Current;
keyFormatter.Serialize(writer, item.Key, options);
valueFormatter.Serialize(writer, item.Value, options);
}
}
finally
{
e.Dispose();
}
}
}
static FormatterCache()
{
foreach (INetDataFormatterResolver item in Resolvers)
{
INetDataFormatter <T> f = item.GetFormatter <T>();
if (f != null)
{
Formatter = f;
return;
}
}
}
public void Serialize(NetDataWriter writer, T[] value, NetDataSerializerOptions options)
{
if (value == null)
{
writer.Write(false);
}
else
{
writer.Write(true);
INetDataFormatter <T> formatter = options.Resolver.GetFormatter <T>();
writer.Write(value.Length);
for (int i = 0; i < value.Length; i++)
{
formatter.Serialize(writer, value[i], options);
}
}
}
static FormatterCache()
{
Formatter = (INetDataFormatter <T>)GeneratedResolverGetFormatterHelper.GetFormatter(typeof(T));
}
public StaticNullableFormatter(INetDataFormatter <T> underlyingFormatter)
{
this.underlyingFormatter = underlyingFormatter;
}
static FormatterCache()
{
Formatter = (INetDataFormatter <T>)DynamicGenericResolverGetFormatterHelper.GetFormatter(typeof(T));
}
