internal static MethodInfo ResolveListAdd(TypeModel model, Type listType, Type itemType, out bool isList)
{
#if WINRT
TypeInfo listTypeInfo = listType.GetTypeInfo();
#else
Type listTypeInfo = listType;
#endif
isList = model.MapType(ilist).IsAssignableFrom(listTypeInfo);
Type[] types = { itemType };
MethodInfo add = Helpers.GetInstanceMethod(listTypeInfo, "Add", types);
#if !NO_GENERICS
if (add == null)
{ // fallback: look for ICollection<T>'s Add(typedObject) method
bool forceList = listTypeInfo.IsInterface &&
model.MapType(typeof(System.Collections.Generic.IEnumerable <>)).MakeGenericType(types)
#if WINRT
.GetTypeInfo()
#endif
.IsAssignableFrom(listTypeInfo);
#if WINRT
TypeInfo constuctedListType = typeof(System.Collections.Generic.ICollection <>).MakeGenericType(types).GetTypeInfo();
#else
Type constuctedListType = model.MapType(typeof(System.Collections.Generic.ICollection <>)).MakeGenericType(types);
#endif
if (forceList || constuctedListType.IsAssignableFrom(listTypeInfo))
{
add = Helpers.GetInstanceMethod(constuctedListType, "Add", types);
}
}
if (add == null)
{
#if WINRT
foreach (Type tmpType in listTypeInfo.ImplementedInterfaces)
#else
foreach (Type interfaceType in listTypeInfo.GetInterfaces())
#endif
{
#if WINRT
TypeInfo interfaceType = tmpType.GetTypeInfo();
#endif
if (interfaceType.Name == "IProducerConsumerCollection`1" && interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition().FullName == "System.Collections.Concurrent.IProducerConsumerCollection`1")
{
add = Helpers.GetInstanceMethod(interfaceType, "TryAdd", types);
if (add != null)
{
break;
}
}
}
}
#endif
if (add == null)
{ // fallback: look for a public list.Add(object) method
types[0] = model.MapType(typeof(object));
add = Helpers.GetInstanceMethod(listTypeInfo, "Add", types);
}
if (add == null && isList)
{ // fallback: look for IList's Add(object) method
add = Helpers.GetInstanceMethod(model.MapType(ilist), "Add", types);
}
return(add);
}
internal static Type GetListItemType(TypeModel model, Type listType)
{
Helpers.DebugAssert(listType != null);
#if WINRT
TypeInfo listTypeInfo = listType.GetTypeInfo();
if (listType == typeof(string) || listType.IsArray ||
!typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(listTypeInfo))
{
return(null);
}
#else
if (listType == model.MapType(typeof(string)) || listType.IsArray ||
!model.MapType(typeof(IEnumerable)).IsAssignableFrom(listType))
{
return(null);
}
#endif
BasicList candidates = new BasicList();
#if WINRT
foreach (MethodInfo method in listType.GetRuntimeMethods())
#else
foreach (MethodInfo method in listType.GetMethods())
#endif
{
if (method.IsStatic || method.Name != "Add")
{
continue;
}
ParameterInfo[] parameters = method.GetParameters();
Type paramType;
if (parameters.Length == 1 && !candidates.Contains(paramType = parameters[0].ParameterType))
{
candidates.Add(paramType);
}
}
string name = listType.Name;
bool isQueueStack = name != null && (name.IndexOf("Queue", System.StringComparison.Ordinal) >= 0 || name.IndexOf("Stack", System.StringComparison.Ordinal) >= 0);
#if !NO_GENERICS
if (!isQueueStack)
{
TestEnumerableListPatterns(model, candidates, listType);
#if WINRT
foreach (Type iType in listTypeInfo.ImplementedInterfaces)
{
TestEnumerableListPatterns(model, candidates, iType);
}
#else
foreach (Type iType in listType.GetInterfaces())
{
TestEnumerableListPatterns(model, candidates, iType);
}
#endif
}
#endif
#if WINRT
// more convenient GetProperty overload not supported on all platforms
foreach (PropertyInfo indexer in listType.GetRuntimeProperties())
{
if (indexer.Name != "Item" || candidates.Contains(indexer.PropertyType))
{
continue;
}
ParameterInfo[] args = indexer.GetIndexParameters();
if (args.Length != 1 || args[0].ParameterType != typeof(int))
{
continue;
}
MethodInfo getter = indexer.GetMethod;
if (getter == null || getter.IsStatic)
{
continue;
}
candidates.Add(indexer.PropertyType);
}
#else
// more convenient GetProperty overload not supported on all platforms
foreach (PropertyInfo indexer in listType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (indexer.Name != "Item" || candidates.Contains(indexer.PropertyType))
{
continue;
}
ParameterInfo[] args = indexer.GetIndexParameters();
if (args.Length != 1 || args[0].ParameterType != model.MapType(typeof(int)))
{
continue;
}
candidates.Add(indexer.PropertyType);
}
#endif
switch (candidates.Count)
{
case 0:
return(null);
case 1:
return((Type)candidates[0]);
case 2:
if (CheckDictionaryAccessors(model, (Type)candidates[0], (Type)candidates[1]))
{
return((Type)candidates[0]);
}
if (CheckDictionaryAccessors(model, (Type)candidates[1], (Type)candidates[0]))
{
return((Type)candidates[1]);
}
break;
}
return(null);
}
public DoubleSerializer(AqlaSerializer.Meta.TypeModel model)
{
#if FEAT_IKVM
expectedType = model.MapType(typeof(double));
#endif
}
public Int64Serializer(AqlaSerializer.Meta.TypeModel model)
{
#if FEAT_IKVM
expectedType = model.MapType(typeof(long));
#endif
}
public StringSerializer(AqlaSerializer.Meta.TypeModel model)
{
#if FEAT_IKVM
expectedType = model.MapType(typeof(string));
#endif
}
public DecimalSerializer(AqlaSerializer.Meta.TypeModel model)
{
#if FEAT_IKVM
expectedType = model.MapType(typeof(decimal));
#endif
}
public static AttributeMap[] Create(TypeModel model, Assembly assembly)
{
#if FEAT_IKVM
const bool inherit = false;
System.Collections.Generic.IList <CustomAttributeData> all = assembly.__GetCustomAttributes(model.MapType(typeof(Attribute)), inherit);
AttributeMap[] result = new AttributeMap[all.Count];
int index = 0;
foreach (CustomAttributeData attrib in all)
{
result[index++] = new AttributeDataMap(attrib);
}
return(result);
#else
#if WINRT
Attribute[] all = System.Linq.Enumerable.ToArray(assembly.GetCustomAttributes());
#else
const bool inherit = false;
object[] all = assembly.GetCustomAttributes(inherit);
#endif
AttributeMap[] result = new AttributeMap[all.Length];
for (int i = 0; i < all.Length; i++)
{
result[i] = new ReflectionAttributeMap((Attribute)all[i]);
}
return(result);
#endif
}