/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref TStack value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
using (var listCache = Cache <List <TValue> > .Claim())
{
var list = listCache.Value;
list.Clear();
foreach (var element in value)
{
list.Add(element);
}
for (int i = list.Count - 1; i >= 0; i--)
{
try
{
TSerializer.WriteValue(list[i], writer);
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Writes the given <see cref="SerializationInfo" /> using the given writer.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo" /> to write.</param>
/// <param name="writer">The writer to use.</param>
private void WriteSerializationInfo(SerializationInfo info, IDataWriter writer)
{
try
{
writer.BeginArrayNode(info.MemberCount);
foreach (var entry in info)
{
try
{
writer.WriteString("type", writer.Binder.BindToName(entry.ObjectType, writer.Context.Config.DebugContext));
var readerWriter = Serializer.Get(entry.ObjectType);
readerWriter.WriteValueWeak(entry.Name, entry.Value, writer);
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref TStack value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
lock (List_LOCK)
{
List.Clear();
foreach (var element in value)
{
List.Add(element);
}
for (int i = List.Count - 1; i >= 0; i--)
{
try
{
TSerializer.WriteValue(List[i], writer);
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
}
}
}
finally
{
writer.EndArrayNode();
}
}
protected override void Write(ref AotList value, IDataWriter writer)
{
writer.BeginArrayNode(value.Count);
for (int i = 0; i < value.Count; i++)
{
ObjectSerializer.WriteValue(value[i], writer);
}
writer.EndArrayNode();
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref T[] value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Length);
for (int i = 0; i < value.Length; i++)
{
valueReaderWriter.WriteValue(value[i], writer);
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref Dictionary <TKey, TValue> value, IDataWriter writer)
{
try
{
if (value.Comparer != null)
{
EqualityComparerSerializer.WriteValue("comparer", value.Comparer, writer);
}
writer.BeginArrayNode(value.Count);
foreach (var pair in value)
{
bool endNode = true;
try
{
writer.BeginStructNode(null, null);
KeyReaderWriter.WriteValue("$k", pair.Key, writer);
ValueReaderWriter.WriteValue("$v", pair.Value, writer);
}
catch (SerializationAbortException ex)
{
endNode = false;
throw ex;
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
finally
{
if (endNode)
{
writer.EndNode(null);
}
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref TArray value, IDataWriter writer)
{
var array = value as Array;
try
{
writer.BeginArrayNode(array.LongLength);
int[] lengths = new int[ArrayRank];
for (int i = 0; i < ArrayRank; i++)
{
lengths[i] = array.GetLength(i);
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ArrayRank; i++)
{
if (i > 0)
{
sb.Append(RANKS_SEPARATOR);
}
sb.Append(lengths[i].ToString(CultureInfo.InvariantCulture));
}
string lengthStr = sb.ToString();
writer.WriteString(RANKS_NAME, lengthStr);
this.IterateArrayRead(
(Array)(object)value,
(v) =>
{
ValueReaderWriter.WriteValue(v, writer);
});
}
finally
{
writer.EndArrayNode();
}
}
protected override void Write(ref AotDictionary dictionary, IDataWriter writer)
{
writer.BeginArrayNode(dictionary.Count);
var keys = new object[dictionary.Keys.Count];
dictionary.Keys.CopyTo(keys, 0);
for (int i = 0; i < dictionary.Count; i++)
{
var key = keys[i];
var value = dictionary[i];
ObjectSerializer.WriteValue(key, writer);
ObjectSerializer.WriteValue(value, writer);
}
writer.EndArrayNode();
}
/// <summary>
/// Serialization implementation.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to write to.</param>
protected override void SerializeImplementation(ref IndexedDictionary <TKey, TValue> value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
bool endNode = true;
for (int i = 0; i < value.Count; i++)
{
var entry = value.Get(i);
try
{
writer.BeginStructNode(null, null);
KeyReaderWriter.WriteValue(entry.Key, writer);
ValueReaderWriter.WriteValue(entry.Value, writer);
}
catch (SerializationAbortException ex)
{
endNode = false;
throw ex;
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
finally
{
if (endNode)
{
writer.EndNode(null);
}
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="!:T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref DoubleLookupDictionary <TPrimary, TSecondary, TValue> value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
bool endNode = true;
foreach (var pair in value)
{
try
{
writer.BeginStructNode(null, null);
PrimaryReaderWriter.WriteValue("$k", pair.Key, writer);
InnerReaderWriter.WriteValue("$v", pair.Value, writer);
}
catch (SerializationAbortException ex)
{
endNode = false;
throw ex;
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
finally
{
if (endNode)
{
writer.EndNode(null);
}
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref HashSet <T> value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
foreach (T item in value)
{
try
{
TSerializer.WriteValue(item, writer);
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
}
}
finally
{
writer.EndArrayNode();
}
}
/// <summary>
/// Provides the actual implementation for serializing a value of type <see cref="T" />.
/// </summary>
/// <param name="value">The value to serialize.</param>
/// <param name="writer">The writer to serialize with.</param>
protected override void SerializeImplementation(ref ArrayList value, IDataWriter writer)
{
try
{
writer.BeginArrayNode(value.Count);
for (int i = 0; i < value.Count; i++)
{
try
{
ObjectSerializer.WriteValue(value[i], writer);
}
catch (Exception ex)
{
writer.Context.Config.DebugContext.LogException(ex);
}
}
}
finally
{
writer.EndArrayNode();
}
}
