internal string GetTypeNameAndType(Type type, out bool isJavaType)
{
Module mod = type.Module;
int moduleIndex = -1;
for (int i = 0; i < modules.Length; i++)
{
if (modules[i] == mod)
{
moduleIndex = i;
break;
}
}
if (isJavaModule[moduleIndex])
{
isJavaType = true;
if (AttributeHelper.IsHideFromJava(type))
{
return(null);
}
return(CompiledTypeWrapper.GetName(type));
}
else
{
isJavaType = false;
if (!DotNetTypeWrapper.IsAllowedOutside(type))
{
return(null);
}
return(DotNetTypeWrapper.GetName(type));
}
}
internal TypeWrapper CreateWrapperForAssemblyType(Type type)
{
Module mod = type.Module;
int moduleIndex = -1;
for (int i = 0; i < modules.Length; i++)
{
if (modules[i] == mod)
{
moduleIndex = i;
break;
}
}
string name;
if (isJavaModule[moduleIndex])
{
name = CompiledTypeWrapper.GetName(type);
}
else
{
name = DotNetTypeWrapper.GetName(type);
}
if (name == null)
{
return(null);
}
if (isJavaModule[moduleIndex])
{
if (AttributeHelper.IsHideFromJava(type))
{
return(null);
}
// since this type was compiled from Java source, we have to look for our
// attributes
return(CompiledTypeWrapper.newInstance(name, type));
}
else
{
if (!DotNetTypeWrapper.IsAllowedOutside(type))
{
return(null);
}
// since this type was not compiled from Java source, we don't need to
// look for our attributes, but we do need to filter unrepresentable
// stuff (and transform some other stuff)
return(DotNetTypeWrapper.Create(type, name));
}
}
public static java.lang.Class getPrecompiledProxy(java.lang.ClassLoader classLoader, string proxyName, java.lang.Class[] interfaces)
{
AssemblyClassLoader acl = ClassLoaderWrapper.GetClassLoaderWrapper(classLoader) as AssemblyClassLoader;
if (acl == null)
{
return(null);
}
TypeWrapper[] wrappers = new TypeWrapper[interfaces.Length];
for (int i = 0; i < wrappers.Length; i++)
{
wrappers[i] = TypeWrapper.FromClass(interfaces[i]);
}
// TODO support multi assembly class loaders
Type type = acl.MainAssembly.GetType(TypeNameUtil.GetProxyName(wrappers));
if (type == null)
{
return(null);
}
TypeWrapper tw = CompiledTypeWrapper.newInstance(proxyName, type);
TypeWrapper tw2 = acl.RegisterInitiatingLoader(tw);
if (tw != tw2)
{
return(null);
}
// we need to explicitly register the type, because the type isn't visible by normal means
tw.GetClassLoader().SetWrapperForType(type, tw);
TypeWrapper[] wrappers2 = tw.Interfaces;
if (wrappers.Length != wrappers.Length)
{
return(null);
}
for (int i = 0; i < wrappers.Length; i++)
{
if (wrappers[i] != wrappers2[i])
{
return(null);
}
}
return(tw.ClassObject);
}
internal TypeWrapper CreateWrapperForAssemblyType(Type type)
{
bool isJavaType;
string name = GetTypeNameAndType(type, out isJavaType);
if (name == null)
{
return(null);
}
if (isJavaType)
{
// since this type was compiled from Java source, we have to look for our
// attributes
return(CompiledTypeWrapper.newInstance(name, type));
}
else
{
// since this type was not compiled from Java source, we don't need to
// look for our attributes, but we do need to filter unrepresentable
// stuff (and transform some other stuff)
return(DotNetTypeWrapper.Create(type, name));
}
}
internal TypeWrapper DoLoad(string name)
{
for (int i = 0; i < modules.Length; i++)
{
if (isJavaModule[i])
{
Type type = GetJavaType(modules[i], name);
if (type != null)
{
// check the name to make sure that the canonical name was used
if (CompiledTypeWrapper.GetName(type) == name)
{
return(CompiledTypeWrapper.newInstance(name, type));
}
}
}
else
{
// TODO should we catch ArgumentException and prohibit array, pointer and byref here?
Type type = GetType(modules[i], DotNetTypeWrapper.DemangleTypeName(name));
if (type != null && DotNetTypeWrapper.IsAllowedOutside(type))
{
// check the name to make sure that the canonical name was used
if (DotNetTypeWrapper.GetName(type) == name)
{
return(DotNetTypeWrapper.Create(type, name));
}
}
}
}
if (hasDotNetModule)
{
// for fake types, we load the declaring outer type (the real one) and
// let that generated the manufactured nested classes
// (note that for generic outer types, we need to duplicate this in ClassLoaderWrapper.LoadGenericClass)
TypeWrapper outer = null;
if (name.EndsWith(DotNetTypeWrapper.DelegateInterfaceSuffix))
{
outer = DoLoad(name.Substring(0, name.Length - DotNetTypeWrapper.DelegateInterfaceSuffix.Length));
}
else if (name.EndsWith(DotNetTypeWrapper.AttributeAnnotationSuffix))
{
outer = DoLoad(name.Substring(0, name.Length - DotNetTypeWrapper.AttributeAnnotationSuffix.Length));
}
else if (name.EndsWith(DotNetTypeWrapper.AttributeAnnotationReturnValueSuffix))
{
outer = DoLoad(name.Substring(0, name.Length - DotNetTypeWrapper.AttributeAnnotationReturnValueSuffix.Length));
}
else if (name.EndsWith(DotNetTypeWrapper.AttributeAnnotationMultipleSuffix))
{
outer = DoLoad(name.Substring(0, name.Length - DotNetTypeWrapper.AttributeAnnotationMultipleSuffix.Length));
}
else if (name.EndsWith(DotNetTypeWrapper.EnumEnumSuffix))
{
outer = DoLoad(name.Substring(0, name.Length - DotNetTypeWrapper.EnumEnumSuffix.Length));
}
if (outer != null && outer.IsFakeTypeContainer)
{
foreach (TypeWrapper tw in outer.InnerClasses)
{
if (tw.Name == name)
{
return(tw);
}
}
}
}
return(null);
}
