public static FieldInfo[] GetFields(Type type, BindingFlags flags)
{
List <FieldInfo> ret = new List <FieldInfo>();
while (type != null && type != typeof(object))
{
GenericTypeInfo typeId = GenericInstanceFactory.GetGenericTypeInfo(type);
var typeDef = typeId != null ? typeId.TypeDefinition : type;
var fields = typeDef.JavaGetDeclaredFields();
int startIndex = ret.Count;
for (int i = 0; i < fields.Length; ++i)
{
if (!TypeHelper.Matches(fields[i].Modifiers, flags))
{
continue;
}
ret.Add(new FieldInfo(fields[i], type));
}
ReorderFields(typeDef, startIndex, ret);
if ((flags & BindingFlags.DeclaredOnly) != 0)
{
break;
}
type = type.BaseType;
}
return(ret.ToArray());
}
public static IEnumerable <MethodInfo> GetMethods(Type type, BindingFlags flags)
{
while (type != null)
{
GenericTypeInfo typeId = GenericInstanceFactory.GetGenericTypeInfo(type);
var typeDef = typeId != null ? typeId.TypeDefinition : type;
string possibleExplicitInterfacePrefix = typeDef.JavaIsInterface() ? typeDef.GetSimpleName() + "_" : null;
var methods = typeDef.JavaGetDeclaredMethods();
for (int i = 0; i < methods.Length; ++i)
{
if (!TypeHelper.Matches(methods[i].Modifiers, flags))
{
continue;
}
yield return(new MethodInfo(methods[i], type, possibleExplicitInterfacePrefix));
}
if ((flags & BindingFlags.DeclaredOnly) != 0)
{
break;
}
type = type.BaseType;
}
}
internal static bool Equals(GenericTypeInfo gti1, Type typeDefinition, Type[] arguments)
{
if (gti1.TypeDefinition != typeDefinition)
{
return(false);
}
var arglen = arguments.Length;
if (arglen != gti1.NumberOfGenericArguments)
{
return(false);
}
var gtiArgs = gti1.Arguments;
for (int i = 0; i < arglen; ++i)
{
if (gtiArgs[i] != arguments[i])
{
return(false);
}
}
return(true);
}
internal static bool Equals(GenericTypeInfo gti1, GenericTypeInfo gti2)
{
if (gti1.HashCode != gti2.HashCode)
{
return(false);
}
if (gti1.TypeDefinition != gti2.TypeDefinition)
{
return(false);
}
var len = gti1.NumberOfGenericArguments;
if (len != gti2.NumberOfGenericArguments)
{
return(false);
}
var args1 = gti1.Arguments;
var args2 = gti2.Arguments;
for (int i = 0; i < len; ++i)
{
if (args1[i] != args2[i])
{
return(false);
}
}
return(true);
}
internal static bool Equals(GenericTypeInfo gti1, Type typeDefinition, Type arg1, Type arg2, Type arg3, Type arg4)
{
if (gti1.TypeDefinition != typeDefinition)
{
return(false);
}
var gtiArgs = gti1.Arguments;
switch (gti1.NumberOfGenericArguments)
{
case 4: if (gtiArgs[3] != arg4)
{
return(false);
}
goto case 3;
case 3: if (gtiArgs[2] != arg3)
{
return(false);
}
goto case 2;
case 2: if (gtiArgs[1] != arg2)
{
return(false);
}
goto case 1;
case 1: return(gtiArgs[0] == arg1);
default:
return(false);
}
}
public static Type GetOrMakeGenericInstanceType(Type baseType, Type[] genericParameters)
{
// TODO: make this work without an allocation.
var typeId = new GenericTypeInfo(baseType, genericParameters);
return(GetOrMakeGenericInstanceType(typeId));
}
public static Type GetOrMakeGenericInstanceType(Type baseType, Type gp1, Type gp2, Type gp3, Type gp4)
{
// TODO: make this work without an allocation.
Type[] arguments;
if (gp2 == null)
{
arguments = new[] { gp1 }
}
;
else if (gp3 == null)
{
arguments = new[] { gp1, gp2 }
}
;
else if (gp4 == null)
{
arguments = new[] { gp1, gp2, gp3 }
}
;
else
{
arguments = new[] { gp1, gp2, gp3, gp4 }
};
var typeId = new GenericTypeInfo(baseType, arguments);
return(GetOrMakeGenericInstanceType(typeId));
}
internal static bool Equals(GenericTypeInfo gti1, Type typeDefinition, Type[] arguments)
{
if (gti1.TypeDefinition != typeDefinition)
return false;
var arglen = arguments.Length;
if (arglen != gti1.NumberOfGenericArguments)
return false;
var gtiArgs = gti1.Arguments;
for (int i = 0; i < arglen; ++i)
if (gtiArgs[i] != arguments[i])
return false;
return true;
}
private static Type GetOrMakeGenericInstanceType(GenericTypeInfo typeId)
{
Type proxyType = TypeInfoToProxyType.Get(typeId);
Type previousProxyType = null;
if (proxyType == null)
{
proxyType = CreateUniqueType();
previousProxyType = TypeInfoToProxyType.PutIfAbsent(typeId, proxyType);
// always put generic parameters, to avoid
// possible race. the final instance doesn't matter.
ProxyTypeToTypeInfo.Put(proxyType, typeId);
}
return(previousProxyType ?? proxyType);
}
public GenericInstanceConstructorInfo(Constructor ctor, Type declaringType, GenericTypeInfo genericType) : base(ctor)
{
_declaringType = declaringType;
_genericType = genericType;
}
public static Type ToGenericInstanceType(Type perceivedType, Type parentType, GenericDefinition m)
{
// is a specialized type defined?
var genericInstanceType = m.GenericInstanceType;
if (genericInstanceType != null)
{
return(genericInstanceType);
}
int genericParameter = -1;
var genericArguments = m.GenericArguments;
// is a generic type definition class defined?
var genericTypeDef = m.GenericTypeDefinition;
if (genericTypeDef == null)
{
genericTypeDef = perceivedType;
genericParameter = m.GenericParameter;
}
// retrieve generic parameters if required.
GenericTypeInfo parentGenericArguments = null;
bool needParentGenericArguments = genericParameter >= 0 ||
genericArguments.Any(a => a.FixedType == null);
if (needParentGenericArguments)
{
parentGenericArguments = GenericInstanceFactory.GetGenericTypeInfo(parentType);
if (parentGenericArguments == null)
{
// Can either happen when the generics reflection annotations where not preserved
// (i.e. a bug), when the user did not call GetTypeReflectionSafe() on an object,
// or when requesting generics info not for an instance type, e.g. typeof(List<>).
// As the second case can be difficult to debug, we emit a warning. TODO: we should
// probably not emit a warning when the user code runs in release mode.
Log.W("dot42", string.Format("Unable to reconstruct generic type definition for type {0}, parent type {1}. Did you use obj.GetTypeReflectionSafe()? If you are reflecting on an open generic type, i.e. typeof(List<>) you can ignore this warning.", perceivedType.FullName, parentType.FullName));
return(genericTypeDef);
}
}
if (genericParameter != -1)
{
// ReSharper disable once PossibleNullReferenceException
genericTypeDef = parentGenericArguments.GetGenericParameter(genericParameter);
}
if (genericArguments != null && genericArguments.Length > 0)
{
Type[] genericParameters = new Type[genericArguments.Length];
for (int i = 0; i < genericArguments.Length; ++i)
{
Type resolvedArg;
var arg = genericArguments[i];
if (arg.NestedType != null)
{
resolvedArg = ToGenericInstanceType(typeof(object), parentType, arg.NestedType);
}
else if (arg.FixedType != null)
{
resolvedArg = arg.FixedType;
}
else
{
// must be an index
// ReSharper disable once PossibleNullReferenceException
resolvedArg = parentGenericArguments.GetGenericParameter(arg.ContainingTypeArgumentIndex);
}
genericParameters[i] = resolvedArg;
}
return(GenericInstanceFactory.GetOrMakeGenericInstanceType(genericTypeDef, genericParameters));
}
// return the type.
return(genericTypeDef);
}
public GenericInstanceConstructorInfo(Constructor ctor, Type declaringType, GenericTypeInfo genericType) : base(ctor)
{
_declaringType = declaringType;
_genericType = genericType;
}
internal static bool Equals(GenericTypeInfo gti1, Type typeDefinition, Type arg1, Type arg2, Type arg3, Type arg4)
{
if (gti1.TypeDefinition != typeDefinition)
return false;
var gtiArgs = gti1.Arguments;
switch (gti1.NumberOfGenericArguments)
{
case 4: if (gtiArgs[3] != arg4) return false; goto case 3;
case 3: if (gtiArgs[2] != arg3) return false; goto case 2;
case 2: if (gtiArgs[1] != arg2) return false; goto case 1;
case 1: return gtiArgs[0] == arg1;
default:
return false;
}
}
internal static bool Equals(GenericTypeInfo gti1, GenericTypeInfo gti2)
{
if (gti1.HashCode != gti2.HashCode) return false;
if (gti1.TypeDefinition != gti2.TypeDefinition) return false;
var len = gti1.NumberOfGenericArguments;
if (len != gti2.NumberOfGenericArguments) return false;
var args1 = gti1.Arguments;
var args2 = gti2.Arguments;
for (int i = 0; i < len; ++i)
if (args1[i] != args2[i])
return false;
return true;
}
