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