public string Visit(NetGenericInstanceType item, bool addDummyGeneric)
{
var prefix = (item.DeclaringType != null) ? item.DeclaringType.Accept(this, true) + "." + item.ElementType.Name : item.ElementType.Accept(this, false);
var args = string.Join(", ", item.GenericArguments.Select(x => x.Accept(this, true)).ToArray());
return(prefix + "<" + args + ">");
}
/// <summary>
/// Resolve a generic instance
/// </summary>
public NetTypeReference Visit(NetGenericInstanceType item, int data)
{
var declaringType = (item.DeclaringType != null) ? item.DeclaringType.Accept(this, data) : null;
var result = new NetGenericInstanceType((NetTypeDefinition)item.ElementType.Accept(this, data), declaringType);
foreach (var arg in item.GenericArguments)
{
result.AddGenericArgument(arg.Accept(this, data), typeNameMap);
}
return(result);
}
public NetTypeReference Visit(GenericInstanceType type, ResolveData data)
{
if (type.ElementType.FullName == "System.Nullable`1")
{
var arg = type.GenericArguments.Single();
return(new NetNullableType(arg.Accept(this, data)));
}
else
{
var declaringType = (type.DeclaringType != null) ? type.DeclaringType.Accept(this, data) : null;
var elementType = type.ElementType.Accept(this, data);
var git = new NetGenericInstanceType((NetTypeDefinition)elementType, declaringType);
foreach (var arg in type.GenericArguments)
{
git.AddGenericArgument(arg.Accept(this, data), null);
}
return(git);
}
}
public bool Visit(NetGenericInstanceType type, INetMemberVisibility member)
{
var rc = type.ElementType.Accept(this, member);
if (type.DeclaringType != null)
{
if (type.DeclaringType.Accept(this, member))
{
rc = true;
}
}
foreach (var arg in type.GenericArguments)
{
if (arg.Accept(this, member))
{
rc = true;
}
}
return(rc);
}
/// <summary>
/// Gets a mapping
/// </summary>
public bool TryGetType(ObjectTypeReference javaTypeRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
NetTypeDefinition typeDef;
if (TryGetByJavaClassName(javaTypeRef.ClassName, out typeDef))
{
// Custom
/*if (typeDef.FullName.StartsWith("System.Type"))
* {
* }*/
// Create result
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count == 0))
{
// Normal non-generic type
result = typeDef;
return(true);
}
if (typeDef.IgnoreGenericArguments)
{
// Force use as normal type
result = typeDef;
return(true);
}
// Generic type is used as non-generic?
NetTypeReference declaringType = null;
if (javaTypeRef.Prefix != null)
{
TryGetType(javaTypeRef.Prefix, target, gcontext, out declaringType);
}
var git = new NetGenericInstanceType(typeDef, declaringType);
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count > 0))
{
// Add "object" arguments
foreach (var tp in typeDef.GenericParameters)
{
git.AddGenericArgument(Object, this);
}
result = git;
return(true);
}
if (javaTypeRef.Arguments.Count() != typeDef.GenericParameters.Count)
{
if ((resolver == null) || (typeDef.GenericParameters.Count != 0) ||
(!resolver.AcceptLackOfGenericParameters))
{
throw new ArgumentException(string.Format("Mismatch between generic parameter count and generic argument count in {0}", javaTypeRef));
}
if ((resolver != null) && (resolver.AcceptLackOfGenericParameters) &&
(typeDef.GenericParameters.Count == 0))
{
result = typeDef;
return(true);
}
}
// Type with generic arguments
foreach (var typeArg in javaTypeRef.Arguments)
{
NetTypeReference arg;
if (typeArg.IsAny)
{
arg = Object;
}
else
{
if (!typeArg.Signature.TryResolve(target, gcontext, false, out arg))
{
arg = Object;
//result = null;
//return false;
}
}
git.AddGenericArgument(arg, this);
}
result = git;
return(true);
}
#if DEBUG
var names = map.Keys.OrderBy(x => x).ToArray();
#endif
//throw new ArgumentException(string.Format("{0} not found", javaTypeRef));
result = null;
return(false);
}
/// <summary>
/// Gets a mapping
/// </summary>
public bool TryGetType(ObjectTypeReference javaTypeRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
NetTypeDefinition typeDef;
if (TryGetByJavaClassName(javaTypeRef.ClassName, out typeDef))
{
// Custom
/*if (typeDef.FullName.StartsWith("System.Type"))
{
}*/
// Create result
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count == 0))
{
// Normal non-generic type
result = typeDef;
return true;
}
if (typeDef.IgnoreGenericArguments)
{
// Force use as normal type
result = typeDef;
return true;
}
// Generic type is used as non-generic?
NetTypeReference declaringType = null;
if (javaTypeRef.Prefix != null)
{
TryGetType(javaTypeRef.Prefix, target, gcontext, out declaringType);
}
var git = new NetGenericInstanceType(typeDef, declaringType);
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count > 0))
{
// Add "object" arguments
foreach (var tp in typeDef.GenericParameters)
{
git.AddGenericArgument(Object, this);
}
result = git;
return true;
}
if (javaTypeRef.Arguments.Count() != typeDef.GenericParameters.Count)
{
if ((resolver == null) || (typeDef.GenericParameters.Count != 0) ||
(!resolver.AcceptLackOfGenericParameters))
{
throw new ArgumentException(string.Format("Mismatch between generic parameter count and generic argument count in {0}", javaTypeRef));
}
if ((resolver != null) && (resolver.AcceptLackOfGenericParameters) &&
(typeDef.GenericParameters.Count == 0))
{
result = typeDef;
return true;
}
}
// Type with generic arguments
foreach (var typeArg in javaTypeRef.Arguments)
{
NetTypeReference arg;
if (typeArg.IsAny)
{
arg = Object;
}
else
{
if (!typeArg.Signature.TryResolve(target, gcontext, false, out arg))
{
arg = Object;
//result = null;
//return false;
}
}
git.AddGenericArgument(arg, this);
}
result = git;
return true;
}
#if DEBUG
var names = map.Keys.OrderBy(x => x).ToArray();
#endif
//throw new ArgumentException(string.Format("{0} not found", javaTypeRef));
result = null;
return false;
}
