public override void ConvertToData(ConverterContext converterContext, ref TData data, T obj) { if (obj == null) { data = null; return; } if (data == null) { // Optimize most common cases if (typeof(TData) == typeof(Dictionary <TDataKey, TDataValue>) || typeof(TData) == typeof(IDictionary <TDataKey, TDataValue>)) { data = (TData)(IDictionary <TDataKey, TDataValue>) new Dictionary <TDataKey, TDataValue>(obj.Count); } else { data = Activator.CreateInstance <TData>(); } } else { data.Clear(); } foreach (var item in obj) { var itemData1 = default(TDataKey); var itemData2 = default(TDataValue); converterContext.ConvertToData(ref itemData1, item.Key); converterContext.ConvertToData(ref itemData2, item.Value); data.Add(itemData1, itemData2); } }
public override void ConvertFromData(ConverterContext converterContext, TData data, ref T source) { if (data == null) { source = null; return; } if (source == null) { // Optimize most common cases if (typeof(T) == typeof(Dictionary <TKey, TValue>) || typeof(T) == typeof(IDictionary <TKey, TValue>)) { source = (T)(IDictionary <TKey, TValue>) new Dictionary <TKey, TValue>(data.Count); } else { source = Activator.CreateInstance <T>(); } } else { source.Clear(); } foreach (var item in data) { var itemData1 = default(TKey); var itemData2 = default(TValue); converterContext.ConvertFromData(item.Key, ref itemData1); converterContext.ConvertFromData(item.Value, ref itemData2); source.Add(itemData1, itemData2); } }
/// <inheritdoc/> public override void ConvertToData(ConverterContext converterContext, ref object data, object obj) { var dataT = (TData)data; var objT = (T)obj; ConvertToData(converterContext, ref dataT, objT); data = dataT; }
/// <inheritdoc/> public override void ConvertFromData(ConverterContext converterContext, object data, ref object obj) { var dataT = (TData)data; var objT = (T)obj; ConvertFromData(converterContext, dataT, ref objT); obj = objT; }
protected DataContentConverterSerializer(Type dataType) { // For now, get data type from converter // Not sure if it will be good enough for everything. // Another option would be to do it when data types are auto-generated. converter = ConverterContext.GetDataConverter(dataType, typeof(TSource), ConverterContext.ConversionType.ObjectToData); if (converter == null) { throw new InvalidOperationException(string.Format("Could not find a valid converter for type {0}", typeof(TSource))); } }
public override void Serialize(ContentSerializerContext context, SerializationStream stream, ref TSource obj) { // Serialize object if (context.Mode == ArchiveMode.Deserialize) { AssetManager.AssetReference assetReference; // Recursively call deserialization of this stream as another type. // We use special DeserializeObjectRecursive instead of DeserializeObject to avoid reopening this stream. var dataObject = context.AssetManager.DeserializeObjectRecursive(null, out assetReference, context.Url, converter.DataType, AssetManagerLoaderSettings.IgnoreReferences, context, stream.NativeStream, SerializationType); object source = null; // Transfer Context information to the Converter ConverterContext converterContext = context.ConverterContext; if (converterContext == null) { // First time: create context, and register current object converterContext = new ConverterContext { Tags = stream.Context.Tags }; context.ConverterContext = converterContext; } // Pre-construct object (if available) converterContext.ConvertFromData(dataObject, ref source, ConvertFromDataFlags.Construct); // If object could be constructed, register it so that it can properly be referenced if (source != null) { context.AssetManager.SetAssetObject(context.AssetReference, source); } // Actually convert object converterContext.ConvertFromData(dataObject, ref source, ConvertFromDataFlags.Convert); obj = (TSource)source; // Unload data object (not necessary anymore) context.AssetManager.Unload(dataObject); } else { // Transfer Context information to the Converter object dataObject = null; converter.ConvertToData(new ConverterContext { Tags = stream.Context.Tags }, ref dataObject, obj); MemberNonSealedSerializer.SerializeExtended(stream, converter.DataType, ref dataObject, context.Mode); } }
public override void ConvertFromData(ConverterContext converterContext, TData data, ref T source) { if (data == null) { source = null; return; } bool isArray = typeof(T) == typeof(TItem[]); if (source == null) { // Optimize most common cases if (typeof(T) == typeof(List <TItem>) || typeof(T) == typeof(IList <TItem>)) { source = (T)(IList <TItem>) new List <TItem>(data.Count); } else if (isArray) { source = (T)(IList <TItem>) new TItem[data.Count]; } else { source = Activator.CreateInstance <T>(); } } else if (!isArray) { source.Clear(); } if (isArray) { var sourceArray = (TItem[])(object)source; for (int i = 0; i < source.Count; ++i) { var itemData = default(TItem); converterContext.ConvertFromData(data[i], ref itemData); sourceArray[i] = itemData; } } else { foreach (var item in data) { var itemData = default(TItem); converterContext.ConvertFromData(item, ref itemData); source.Add(itemData); } } }
public override void ConvertToData(ConverterContext converterContext, ref TData data, T obj) { if (obj == null) { data = null; return; } bool isArray = typeof(TData) == typeof(TDataItem[]); if (data == null) { // Optimize most common cases if (typeof(TData) == typeof(List <TDataItem>) || typeof(TData) == typeof(IList <TDataItem>)) { data = (TData)(IList <TDataItem>) new List <TDataItem>(obj.Count); } else if (isArray) { data = (TData)(IList <TDataItem>) new TDataItem[obj.Count]; } else { data = Activator.CreateInstance <TData>(); } } else if (!isArray) { data.Clear(); } int index = 0; foreach (var item in obj) { var itemData = default(TDataItem); converterContext.ConvertToData(ref itemData, item); if (isArray) { data[index] = itemData; } else { data.Add(itemData); } index++; } }
public override void ConvertFromData(ConverterContext converterContext, ContentReference <TData> data, ref TSource source) { var contentSerializerContext = converterContext.Tags.Get(ContentSerializerContext.ContentSerializerContextProperty); // TODO: Load through AssetManager if not loaded yet. if (contentSerializerContext != null) { // Not loaded yet? var parentAssetReference = contentSerializerContext.AssetReference; AssetManager.AssetReference assetReference; var value = contentSerializerContext.AssetManager.DeserializeObject(parentAssetReference, out assetReference, data.Location, typeof(TSource), AssetManagerLoaderSettings.IgnoreReferences, converterContext); source = converterContext.ConvertFromData <TSource>(value); } else { source = converterContext.ConvertFromData <TSource>(data.Value); } }
public override void ConvertToData(ConverterContext converterContext, ref ContentReference <TData> data, TSource obj) { var contentSerializerContext = converterContext.Tags.Get(ContentSerializerContext.ContentSerializerContextProperty); // TODO: When to stop conversion and switch to Location? if (contentSerializerContext != null) { data = new ContentReference <TData>() { Value = converterContext.ConvertToData <TData>(obj) }; } else { data = new ContentReference <TData>() { Value = converterContext.ConvertToData <TData>(obj) }; } }
/// <summary> /// Converts the given source object to its data counterpart. /// </summary> /// <param name="converterContext">The converter context.</param> /// <param name="data">The data.</param> /// <param name="obj">The object.</param> public abstract void ConvertToData(ConverterContext converterContext, ref object data, object obj);
public virtual void ConstructFromData(ConverterContext converterContext, object data, ref object obj) { }
/// <summary> /// Converts the given source object to its data counterpart. /// </summary> /// <param name="converterContext">The converter context.</param> /// <param name="data">The data.</param> /// <param name="obj"></param> public abstract void ConvertToData(ConverterContext converterContext, ref TData data, T obj);
public abstract void ConvertFromData(ConverterContext converterContext, TData data, ref T obj);
public virtual void ConstructFromData(ConverterContext converterContext, TData data, ref T obj) { }