/// <summary>
/// Constructs a new instance for a specific list type
/// </summary>
/// <param name="context"><see cref="FudgeContext"/> for this surrogate.</param>
/// <param name="typeData"><see cref="TypeData"/> describing the type to serialize.</param>
public ListSurrogate(FudgeContext context, TypeData typeData)
: base(context, typeData, "SerializeList", "DeserializeList")
{
}
/// <summary>
/// Detects whether a given type can be serialized with this class.
/// </summary>
/// <param name="typeData">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData typeData)
{
Type elementType;
return(IsList(typeData.Type, out elementType));
}
/// <summary>
/// Determines whether a given type can be serialized with this class.
/// </summary>
/// <param
/// name="typeData">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData typeData)
{
return(typeData.GetCustomAttribute <DataContractAttribute>() != null);
}
/// <summary>
/// Detects whether a given type can be serialized with this class.
/// </summary>
/// <param name="type">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData type)
{
return(type.Type.IsArray);
}
/// <summary>
/// Detects whether a given type can be serialized with this class.
/// </summary>
/// <param
/// name="typeData">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData typeData)
{
return(typeof(ISerializable).IsAssignableFrom(typeData.Type) && FindConstructor(typeData) != null);
}
private static ConstructorInfo FindConstructor(TypeData typeData)
{
var constructor = typeData.Type.GetConstructor(BindingFlags.CreateInstance | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null);
return(constructor);
}
private static MethodInfo GetToMsg(TypeData typeData)
{
return(typeData.PublicMethods.FirstOrDefault(m => m.Name == "ToFudgeMsg" &&
m.ReturnType == typeof(void) &&
ParamMatch(m, new Type[] { typeof(IAppendingFudgeFieldContainer), typeof(IFudgeSerializer) })));
}
private static MethodInfo GetFromMsg(TypeData typeData)
{
return(typeData.StaticPublicMethods.FirstOrDefault(m => m.Name == "FromFudgeMsg" &&
m.ReturnType == typeData.Type &&
ParamMatch(m, new Type[] { typeof(IFudgeFieldContainer), typeof(IFudgeDeserializer) })));
}
/// <summary>
/// Detects whether a given type can be serialized with this class.
/// </summary>
/// <param name="typeData">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData typeData)
{
return(IsDictionary(typeData.Type));
}
internal static bool CanHandle(TypeData typeData)
{
return(GetToMsg(typeData) != null && GetFromMsg(typeData) != null);
}
/// <summary>
/// Constructs a new instance for a specific dictionary type
/// </summary>
/// <param name="context"><see cref="FudgeContext"/> for this surrogate.</param>
/// <param name="typeData"><see cref="TypeData"/> describing the type to serialize.</param>
public DictionarySurrogate(FudgeContext context, TypeData typeData)
: base(context, typeData, "SerializeDictionary", "DeserializeDictionary")
{
}
private static TypeKind CalcKind(FudgeContext context, TypeDataCache typeCache, Type type, FudgeFieldNameConvention fieldNameConvention, out TypeData subType, out TypeData subType2, out FudgeFieldType fieldType)
{
// REVIEW 2010-02-14 t0rx -- There seems to be some duplication here with the FudgeSurrogateSelector, should look at joining up
subType = null;
subType2 = null;
fieldType = context.TypeDictionary.GetByCSharpType(type);
if (fieldType != null)
{
// Just a simple field
return(TypeKind.FudgePrimitive);
}
// Check for arrays
if (type.IsArray)
{
subType = typeCache.GetTypeData(type.GetElementType(), fieldNameConvention);
return(TypeKind.Inline);
}
// Check for dictionaries
Type keyType, valueType;
if (DictionarySurrogate.IsDictionary(type, out keyType, out valueType))
{
subType = typeCache.GetTypeData(keyType, fieldNameConvention);
subType2 = typeCache.GetTypeData(valueType, fieldNameConvention);
return(TypeKind.Inline);
}
// Check for lists
Type elementType;
if (ListSurrogate.IsList(type, out elementType))
{
subType = typeCache.GetTypeData(elementType, fieldNameConvention);
return(TypeKind.Inline);
}
return(TypeKind.Reference);
}
private IFudgeSerializationSurrogate SurrogateFromAttribute(FudgeContext context, TypeData typeData)
{
var surrogateAttribute = typeData.CustomAttributes.FirstOrDefault(attrib => attrib is FudgeSurrogateAttribute);
if (surrogateAttribute != null)
{
return(BuildSurrogate(typeData.Type, (FudgeSurrogateAttribute)surrogateAttribute));
}
return(null);
}
private IFudgeSerializationSurrogate SurrogateFromDotNetSurrogateSelector(FudgeContext context, TypeData typeData)
{
if (DotNetSurrogateSelector == null)
{
return(null);
}
ISurrogateSelector selector;
StreamingContext sc = new StreamingContext(StreamingContextStates.Persistence);
ISerializationSurrogate dotNetSurrogate = DotNetSurrogateSelector.GetSurrogate(typeData.Type, sc, out selector);
if (dotNetSurrogate == null)
{
return(null);
}
return(new DotNetSerializationSurrogateSurrogate(context, typeData, dotNetSurrogate, selector));
}
/// <summary>
/// Detects whether a given type can be serialized with this class.
/// </summary>
/// <param
/// name="typeData">Type to test.</param>
/// <returns><c>true</c> if this class can handle the type.</returns>
public static bool CanHandle(TypeData typeData)
{
return(typeData.GetCustomAttribute <SerializableAttribute>() != null);
}
