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