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); } }