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