public static void Translate <T>(
this ITranslator translator,
ref List <T> list,
NodePacketValueFactory <T> valueFactory) where T : class, ITranslatable
{
translator.Translate(ref list, AdaptFactory(valueFactory));
}
/// <summary>
/// Translates a list of T where T implements INodePacketTranslateable
/// </summary>
/// <param name="list">The list to be translated.</param>
/// <param name="factory">Factory to deserialize T</param>
/// <typeparam name="T">TaskItem type</typeparam>
public void Translate <T>(ref List <T> list, NodePacketValueFactory <T> factory) where T : INodePacketTranslatable
{
IList <T> listAsInterface = list;
Translate(ref listAsInterface, factory, count => new List <T>(count));
list = (List <T>)listAsInterface;
}
public static void TranslateArray <T>(
this ITranslator translator,
ref T[] array,
NodePacketValueFactory <T> valueFactory) where T : class, ITranslatable
{
translator.TranslateArray(ref array, AdaptFactory(valueFactory));
}
public static void TranslateDictionary <T>(
this ITranslator translator,
ref Dictionary <string, T> dictionary,
IEqualityComparer <string> comparer,
NodePacketValueFactory <T> valueFactory) where T : class, ITranslatable
{
translator.TranslateDictionary(ref dictionary, comparer, AdaptFactory(valueFactory));
}
public static void Translate <T, L>(
this ITranslator translator,
ref IList <T> list,
NodePacketValueFactory <T> valueFactory,
NodePacketCollectionCreator <L> collectionFactory) where L : IList <T> where T : ITranslatable
{
translator.Translate(ref list, AdaptFactory(valueFactory), collectionFactory);
}
public static void TranslateDictionary <D, T>(
this ITranslator translator,
ref D dictionary,
NodePacketValueFactory <T> valueFactory)
where D : IDictionary <string, T>, new()
where T : class, ITranslatable
{
translator.TranslateDictionary(ref dictionary, AdaptFactory(valueFactory));
}
static ObjectTranslator <T> AdaptFactory <T>(NodePacketValueFactory <T> valueFactory) where T : ITranslatable
{
void Translate(ITranslator translator, ref T objectToTranslate)
{
TranslatorHelpers.Translate <T>(translator, ref objectToTranslate, valueFactory);
}
return(Translate);
}
static ObjectTranslator <T> AdaptFactory <T>(NodePacketValueFactory <T> valueFactory) where T : ITranslatable
{
void TranslateUsingValueFactory(ITranslator translator, ref T objectToTranslate)
{
translator.Translate(ref objectToTranslate, valueFactory);
}
return(TranslateUsingValueFactory);
}
public static void TranslateDictionary <D, T>(
this ITranslator translator,
ref D dictionary,
NodePacketValueFactory <T> valueFactory,
NodePacketCollectionCreator <D> collectionCreator)
where D : IDictionary <string, T>
where T : class, ITranslatable
{
translator.TranslateDictionary(ref dictionary, AdaptFactory(valueFactory), collectionCreator);
}
/// <summary>
/// Translates an object implementing INodePacketTranslatable which does not expose a
/// public parameterless constructor.
/// </summary>
/// <typeparam name="T">The reference type.</typeparam>
/// <param name="value">The value to be translated.</param>
/// <param name="factory">The factory method used to instantiate values of type T.</param>
public void Translate <T>(ref T value, NodePacketValueFactory <T> factory)
where T : INodePacketTranslatable
{
if (!TranslateNullable(value))
{
return;
}
value = factory(this);
}
/// <summary>
/// Translates an array of objects implementing INodePacketTranslatable requiring a factory to create.
/// </summary>
/// <typeparam name="T">The reference type.</typeparam>
/// <param name="array">The array to be translated.</param>
/// <param name="factory">The factory method used to instantiate values of type T.</param>
public void TranslateArray <T>(ref T[] array, NodePacketValueFactory <T> factory)
where T : INodePacketTranslatable
{
if (!TranslateNullable(array))
{
return;
}
int count = array.Length;
_writer.Write(count);
for (int i = 0; i < count; i++)
{
array[i].Translate(this);
}
}
/// <summary>
/// Translates a list of T where T implements INodePacketTranslateable
/// </summary>
/// <param name="list">The list to be translated.</param>
/// <param name="factory">factory to create type T</param>
/// <param name="collectionFactory">factory to create the IList</param>
/// <typeparam name="T">A TaskItemType</typeparam>
/// <typeparam name="L">IList subtype</typeparam>
public void Translate <T, L>(ref IList <T> list, NodePacketValueFactory <T> factory, NodePacketCollectionCreator <L> collectionFactory) where T : INodePacketTranslatable where L : IList <T>
{
if (!TranslateNullable(list))
{
return;
}
int count = list.Count;
_writer.Write(count);
for (int i = 0; i < count; i++)
{
T value = list[i];
Translate <T>(ref value, factory);
}
}
/// <summary>
/// Translates an array of objects implementing INodePacketTranslatable requiring a factory to create.
/// </summary>
/// <typeparam name="T">The reference type.</typeparam>
/// <param name="array">The array to be translated.</param>
/// <param name="factory">The factory method used to instantiate values of type T.</param>
public void TranslateArray <T>(ref T[] array, NodePacketValueFactory <T> factory)
where T : INodePacketTranslatable
{
if (!TranslateNullable(array))
{
return;
}
int count = _reader.ReadInt32();
array = new T[count];
for (int i = 0; i < count; i++)
{
array[i] = factory(this);
}
}
/// <summary>
/// Translates a list of T where T implements INodePacketTranslateable
/// </summary>
/// <param name="list">The list to be translated.</param>
/// <param name="factory">factory to create type T</param>
/// <typeparam name="T">A TaskItemType</typeparam>
public void Translate <T>(ref List <T> list, NodePacketValueFactory <T> factory) where T : INodePacketTranslatable
{
if (!TranslateNullable(list))
{
return;
}
int count = list.Count;
_writer.Write(count);
for (int i = 0; i < count; i++)
{
T value = list[i];
Translate <T>(ref value, factory);
}
}
/// <summary>
/// Translates an object implementing <see cref="ITranslatable"/> which does not expose a
/// public parameterless constructor.
/// </summary>
/// <typeparam name="T">The reference type.</typeparam>
/// <param name="translator">The translator</param>
/// <param name="instance">The value to be translated.</param>
/// <param name="valueFactory">The factory method used to instantiate values of type T.</param>
public static void Translate <T>(
this ITranslator translator,
ref T instance,
NodePacketValueFactory <T> valueFactory) where T : ITranslatable
{
if (!translator.TranslateNullable(instance))
{
return;
}
if (translator.Mode == TranslationDirection.ReadFromStream)
{
instance = valueFactory(translator);
}
else
{
instance.Translate(translator);
}
}
/// <summary>
/// Translates a dictionary of { string, T } for dictionaries with public parameterless constructors.
/// </summary>
/// <typeparam name="D">The reference type for the dictionary.</typeparam>
/// <typeparam name="T">The reference type for values in the dictionary.</typeparam>
/// <param name="dictionary">The dictionary to be translated.</param>
/// <param name="valueFactory">The factory used to instantiate values in the dictionary.</param>
/// <param name="dictionaryCreator">The delegate used to instantiate the dictionary.</param>
public void TranslateDictionary <D, T>(ref D dictionary, NodePacketValueFactory <T> valueFactory, NodePacketCollectionCreator <D> dictionaryCreator)
where D : IDictionary <string, T>
where T : class, INodePacketTranslatable
{
if (!TranslateNullable(dictionary))
{
return;
}
int count = dictionary.Count;
_writer.Write(count);
foreach (KeyValuePair <string, T> pair in dictionary)
{
string key = pair.Key;
Translate(ref key);
T value = pair.Value;
Translate(ref value, valueFactory);
}
}
public static void TranslateHashSet <T>(
this ITranslator translator,
ref HashSet <T> hashSet,
NodePacketValueFactory <T> valueFactory,
NodePacketCollectionCreator <HashSet <T> > collectionFactory) where T : class, ITranslatable
{
if (!translator.TranslateNullable(hashSet))
{
return;
}
int count = default;
if (translator.Mode == TranslationDirection.WriteToStream)
{
count = hashSet.Count;
}
translator.Translate(ref count);
if (translator.Mode == TranslationDirection.ReadFromStream)
{
hashSet = collectionFactory(count);
for (int i = 0; i < count; i++)
{
T value = default;
translator.Translate(ref value, valueFactory);
hashSet.Add(value);
}
}
if (translator.Mode == TranslationDirection.WriteToStream)
{
foreach (T item in hashSet)
{
T value = item;
translator.Translate(ref value, valueFactory);
}
}
}
/// <summary>
/// Translates a dictionary of { string, T } for dictionaries with public parameterless constructors.
/// </summary>
/// <typeparam name="D">The reference type for the dictionary.</typeparam>
/// <typeparam name="T">The reference type for values in the dictionary.</typeparam>
/// <param name="dictionary">The dictionary to be translated.</param>
/// <param name="valueFactory">The factory used to instantiate values in the dictionary.</param>
/// <param name="dictionaryCreator">The delegate used to instantiate the dictionary.</param>
public void TranslateDictionary <D, T>(ref D dictionary, NodePacketValueFactory <T> valueFactory, NodePacketCollectionCreator <D> dictionaryCreator)
where D : IDictionary <string, T>
where T : class, INodePacketTranslatable
{
if (!TranslateNullable(dictionary))
{
return;
}
int count = _reader.ReadInt32();
dictionary = dictionaryCreator(count);
for (int i = 0; i < count; i++)
{
string key = null;
Translate(ref key);
T value = null;
Translate(ref value, valueFactory);
dictionary[key] = value;
}
}
public void Translate <T, L>(ref IList <T> list, NodePacketValueFactory <T> factory, NodePacketCollectionCreator <L> collectionFactory) where T : INodePacketTranslatable where L : IList <T>
{
if (!TranslateNullable(list))
{
return;
}
int count = _reader.ReadInt32();
list = collectionFactory(count);
for (int i = 0; i < count; i++)
{
T value = default(T);
if (!TranslateNullable(value))
{
continue;
}
value = factory(this);
list.Add(value);
}
}
/// <summary>
/// Translates a list of T where T implements INodePacketTranslateable
/// </summary>
/// <param name="list">The list to be translated.</param>
/// <param name="factory">Factory to deserialize T</param>
/// <typeparam name="T">TaskItem type</typeparam>
public void Translate <T>(ref List <T> list, NodePacketValueFactory <T> factory) where T : INodePacketTranslatable
{
if (!TranslateNullable(list))
{
return;
}
int count = _reader.ReadInt32();
list = new List <T>(count);
for (int i = 0; i < count; i++)
{
T value = default(T);
if (!TranslateNullable(value))
{
continue;
}
value = factory(this);
list.Add(value);
}
}
/// <summary>
/// Translates a dictionary of { string, T }.
/// </summary>
/// <typeparam name="T">The reference type for the values, which implements INodePacketTranslatable.</typeparam>
/// <param name="dictionary">The dictionary to be translated.</param>
/// <param name="comparer">The comparer used to instantiate the dictionary.</param>
/// <param name="valueFactory">The factory used to instantiate values in the dictionary.</param>
public void TranslateDictionary <T>(ref Dictionary <string, T> dictionary, IEqualityComparer <string> comparer, NodePacketValueFactory <T> valueFactory)
where T : class, INodePacketTranslatable
{
if (!TranslateNullable(dictionary))
{
return;
}
int count = _reader.ReadInt32();
dictionary = new Dictionary <string, T>(count, comparer);
for (int i = 0; i < count; i++)
{
string key = null;
Translate(ref key);
T value = null;
Translate(ref value, valueFactory);
dictionary[key] = value;
}
}
/// <summary>
/// Translates a dictionary of { string, T }.
/// </summary>
/// <typeparam name="T">The reference type for the values, which implements INodePacketTranslatable.</typeparam>
/// <param name="dictionary">The dictionary to be translated.</param>
/// <param name="comparer">The comparer used to instantiate the dictionary.</param>
/// <param name="valueFactory">The factory used to instantiate values in the dictionary.</param>
public void TranslateDictionary <T>(ref Dictionary <string, T> dictionary, IEqualityComparer <string> comparer, NodePacketValueFactory <T> valueFactory)
where T : class, INodePacketTranslatable
{
if (!TranslateNullable(dictionary))
{
return;
}
int count = dictionary.Count;
_writer.Write(count);
foreach (KeyValuePair <string, T> pair in dictionary)
{
string key = pair.Key;
Translate(ref key);
T value = pair.Value;
Translate(ref value, valueFactory);
}
}
