public override void ModifyMethodName(NetMethodDefinition method, MethodRenamer renamer)
{
if(method.Name == "GetTitle")
renamer.Rename(method, "JavaGetTitle");
else
base.ModifyMethodName(method, renamer);
}
/// <summary>
/// Modify the name of the given method to another name.
/// By calling renamer.Rename, all methods in the same group are also updated.
/// </summary>
public override void ModifyMethodName(NetMethodDefinition method, MethodRenamer renamer)
{
base.ModifyMethodName(method, renamer);
if (method.OriginalJavaName == "getMessage")
{
method.EditorBrowsableState = EditorBrowsableState.Never;
}
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected override bool IsGetter(NetMethodDefinition method)
{
var name = method.OriginalJavaName;
if (name == "getAndDecrement") return false;
if (name == "getAndIncrement") return false;
return base.IsGetter(method);
}
public override void ModifyMethodName(NetMethodDefinition method, MethodRenamer renamer)
{
if (method.OriginalJavaName == "getLayoutParams")
renamer.Rename(method, "GetLayoutParameters");
else if (method.OriginalJavaName == "setLayoutParams")
renamer.Rename(method, "SetLayoutParameters");
else
base.ModifyMethodName(method, renamer);
}
/// <summary>
/// Create a property name from the given getter.
/// </summary>
protected override string GetPropertyName(NetMethodDefinition getter)
{
switch (getter.Name)
{
case "GetPath":
return "AbsolutePath";
default:
return base.GetPropertyName(getter);
}
}
/// <summary>
/// Create a property name from the given getter.
/// </summary>
protected override string GetPropertyName(NetMethodDefinition getter)
{
switch (getter.Name)
{
case "GetCause":
return "InnerException";
case "GetStackTrace":
return "JavaStackTrace";
default:
return base.GetPropertyName(getter);
}
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected override bool IsSetter(NetMethodDefinition method)
{
var name = method.OriginalJavaName;
if (_skipOriginalJavaProperties != null && _skipOriginalJavaProperties.Contains(name))
return false;
if (_isPropertyPredicate != null)
{
var ret = _isPropertyPredicate(method);
if (ret != null) return ret.Value;
}
return base.IsSetter(method);
}
/// <summary>
/// Mark this method as an explicit interface implementation.
/// </summary>
public void SetExplicitImplementation(NetMethodDefinition iMethod, NetTypeReference iType)
{
if (iMethod == null)
{
throw new ArgumentNullException("iMethod");
}
if (iType == null)
{
throw new ArgumentNullException("iType");
}
InterfaceMethod = iMethod;
InterfaceType = iType;
}
/// <summary>
/// Rename the all methods in the method group of the given method to the given new name.
/// </summary>
public void Rename(NetMethodDefinition method, string newName)
{
if (method.Name == newName)
return;
var group = method.MethodGroup;
if (group == null)
{
if (method.IsStatic)
{
method.SetName(newName);
return;
}
if (method.IsConstructor)
{
throw new InvalidOperationException("Constructor cannot be renamed");
}
throw new InvalidOperationException("Method has no group");
}
foreach (var m in group)
{
m.SetName(newName);
}
}
/// <summary>
/// Add the given mapping
/// </summary>
public void Add(MethodDefinition javaMethod, NetMethodDefinition netMethod)
{
map.Add(javaMethod, netMethod);
}
/// <summary>
/// Is the given method a property set method?
/// </summary>
protected virtual bool IsSetter(NetMethodDefinition method)
{
if (method.Parameters.Count != 1)
return false;
if (!method.ReturnType.IsVoid())
return false;
var name = method.Name;
var prefix = GetNamePrefix(name);
return prefix == "Set" || prefix == "set_";
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected virtual bool IsGetter(NetMethodDefinition method)
{
if (method.Parameters.Count > 0)
return false;
if (method.ReturnType.IsVoid())
return false;
var name = method.Name;
if (name == "GetHashCode")
return false;
var prefix = GetNamePrefix(name);
return prefix == "Get" || prefix == "Has" || prefix == "Can" || prefix == "Is" || prefix == "get_";
}
/// <summary>
/// Mark this method as an explicit interface implementation.
/// </summary>
public void SetExplicitImplementation(NetMethodDefinition iMethod, NetTypeReference iType)
{
if (iMethod == null)
throw new ArgumentNullException("iMethod");
if (iType == null)
throw new ArgumentNullException("iType");
InterfaceMethod = iMethod;
InterfaceType = iType;
}
/// <summary>
/// Are the two methods equal wrt name, parameters and type parameter count AND return type?
/// </summary>
internal static bool IsExactDuplicate(this NetMethodDefinition method1, NetMethodDefinition method2)
{
return method1.IsDuplicate(method2) && (method1.ReturnType.AreSame(method2.ReturnType));
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected override bool IsGetter(NetMethodDefinition method)
{
return false;
}
protected override bool IsGetter(NetMethodDefinition method)
{
if (method.Name == "GetMessage") return false;
return base.IsGetter(method);
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected override bool IsGetter(NetMethodDefinition method)
{
if (method.Parameters.Count == 0 && method.Name.StartsWith("Is"))
{
return true;
}
return false;
}
/// <summary>
/// Create the method in the given type
/// </summary>
public void Create(NetTypeDefinition declaringType, TargetFramework target)
{
try
{
// Do not add private methods
if (javaMethod.IsPrivate)
{
if (javaMethod.Name != "<init>")
{
return;
}
}
// Do not add useless bridges methods
if (javaMethod.IsBridge)
{
var targetMethod = javaMethod.DeclaringClass.Methods.FirstOrDefault(x => javaMethod.IsBridgeFor(x));
/*if (javaMethod.DeclaringClass.Methods.Any(x =>
(x != javaMethod) && (x.Name == javaMethod.Name) &&
(x.Parameters.Count == javaMethod.Parameters.Count) &&
(x.Descriptor != javaMethod.Descriptor)))*/
if (targetMethod != null)
{
if (!(targetMethod.IsAbstract && !javaMethod.IsAbstract))
{
return;
}
}
}
// We're using a dummy return type first.
// Otherwise we cannot resolve generic return types.
var signature = javaMethod.Signature;
var nameInfo = declaringTypeBuilder.GetMethodName(javaMethod);
var name = nameInfo.Name;
if (nameInfo.IsConstructor)
{
method = new NetMethodDefinition(".ctor", javaMethod, declaringType, target, convertSignedBytes, "MethodBuilder.Create")
{
AccessFlags = (int) javaMethod.AccessFlags,
EditorBrowsableState = nameInfo.EditorBrowsableState
};
}
else if (nameInfo.IsDeconstructor)
{
method = new NetMethodDefinition("Finalize", javaMethod, declaringType, target, convertSignedBytes, "MethodBuilder.Create")
{
AccessFlags = (int) javaMethod.AccessFlags,
EditorBrowsableState = EditorBrowsableState.Always,
IsDeconstructor = true
};
}
else
{
method = new NetMethodDefinition(name, javaMethod, declaringType, target, convertSignedBytes, "MethodBuilder.Create")
{
AccessFlags = (int) javaMethod.AccessFlags,
EditorBrowsableState = nameInfo.EditorBrowsableState
};
foreach (var typeParam in signature.TypeParameters)
{
method.GenericParameters.Add(
new NetGenericParameter(
TypeBuilder.GetMethodGenericParameterName(declaringType, typeParam.Name),
typeParam.Name, method));
}
var javaReturnType = signature.ReturnType;
NetTypeReference returnType;
if (!javaReturnType.TryResolve(target, this, convertSignedBytes, out returnType))
{
method = null;
return;
}
method.ReturnType = returnType;
}
method.OriginalJavaName = javaMethod.Name;
// Find documentation
var docClass = declaringTypeBuilder.Documentation;
if (docClass != null)
{
// Look for matches by name and parameter count first.
// If there is more then 1 match, we look to the parameter types.
var model = target.XmlModel;
var matches = docClass.Methods.Where(x => Matches(x, false, model)).ToList();
if (matches.Count == 1)
{
docMethod = matches[0];
}
else if (matches.Count > 0)
{
docMethod = matches.FirstOrDefault(x => Matches(x, true, model));
}
}
method.Attributes = declaringTypeBuilder.GetMethodAttributes(javaMethod, GetAttributes(declaringType, method, javaMethod, name, target.TypeNameMap));
var paramIndex = 0;
foreach (var iterator in signature.Parameters)
{
var paramType = iterator;
if (paramType.IsJavaLangVoid())
{
paramType = new ObjectTypeReference("java/lang/Object", null);
}
NetTypeReference resolvedParamType;
if (!paramType.TryResolve(target, this, convertSignedBytes, out resolvedParamType))
{
method = null;
return; // Sometimes public methods used parameters with internal types
}
var docParam = (docMethod != null)
? docMethod.Parameters.ElementAtOrDefault(method.Parameters.Count)
: null;
var paramName = MakeParameterNameUnique(CreateParameterName(resolvedParamType, docParam, target),
method);
var isParams = javaMethod.IsVarArgs && (paramIndex == signature.Parameters.Count - 1);
method.Parameters.Add(new NetParameterDefinition(paramName, resolvedParamType, isParams));
paramIndex++;
}
method.Description = (docMethod != null) ? docMethod.Description : null;
declaringType.Methods.Add(method);
if (!convertSignedBytes)
{
target.MethodMap.Add(javaMethod, method);
}
}
catch (ClassNotFoundException ex)
{
Console.WriteLine("Class {0} not found in {1}", ex.ClassName, javaMethod.Descriptor);
method = null;
}
}
/// <summary>
/// Add a postfix to the given parameter name to make it unique.
/// </summary>
private static string MakeParameterNameUnique(string name, NetMethodDefinition method)
{
var baseName = name;
if (Keywords.IsKeyword(name))
name = "@" + name;
if (method.Parameters.All(x => x.Name != name))
return name;
var index = 1;
while (true)
{
var extName = baseName + index;
if (method.Parameters.All(x => x.Name != extName))
return extName;
index++;
}
}
/// <summary>
/// Create type attributes
/// </summary>
private static MethodAttributes GetAttributes(NetTypeDefinition declaringType, NetMethodDefinition method, MethodDefinition javaMethod, string methodName, TypeNameMap typeNameMap)
{
var result = (MethodAttributes) 0;
var isStatic = javaMethod.IsStatic;
if (javaMethod.IsPublic) result |= MethodAttributes.Public;
else if (javaMethod.IsProtected) result |= MethodAttributes.FamORAssem;
else if (javaMethod.IsPrivate) result |= MethodAttributes.Private;
else if (javaMethod.IsPackagePrivate) result |= MethodAttributes.Assembly;
if (isStatic) result |= MethodAttributes.Static;
if (javaMethod.IsAbstract) result |= MethodAttributes.Abstract;
if (declaringType.IsInterface) result |= MethodAttributes.Abstract;
if ((!javaMethod.IsFinal) && !isStatic && (methodName != ".ctor") && (!declaringType.IsStruct))
{
result |= MethodAttributes.Virtual;
}
else
{
result |= MethodAttributes.Final;
}
if (methodName == ".cctor")
{
result |= MethodAttributes.Static;
}
if (declaringType.IsSealed)
{
result &= ~MethodAttributes.Virtual;
}
return result;
}
/// <summary>
/// Is the given method a property set method?
/// </summary>
protected virtual bool IsSetter(NetMethodDefinition method)
{
if (method.Parameters.Count != 1)
return false;
if (!method.ReturnType.IsVoid())
return false;
var name = method.Name;
if (!name.StartsWith("Set"))
return false;
if (name.Length < 4)
return false;
return true;
}
/// <summary>
/// Find the first matching set method.
/// </summary>
protected virtual NetMethodDefinition FindSetter(NetMethodDefinition getMethod, IEnumerable<NetMethodDefinition> setters)
{
var name = "Set" + getMethod.Name.Substring(3);
var type = getMethod.ReturnType;
return setters.FirstOrDefault(x => x.Name == name && x.Parameters[0].ParameterType.AreSame(type));
}
/// <summary>
/// Gets a mapping.
/// Throws an error if not found.
/// </summary>
public bool TryGet(MethodDefinition javaMethod, out NetMethodDefinition result)
{
return map.TryGetValue(javaMethod, out result);
}
/// <summary>
/// Customize the custom attributes collection of the given method.
/// </summary>
protected virtual void AddCustomAttributes(NetMethodDefinition method, List<NetCustomAttribute> customAttributes)
{
//Nothing to do here
}
/// <summary>
/// Returns true if the given boolean property should be prefixed by "Is"
/// </summary>
protected virtual bool AddIsPrefixToBoolProperty(string name, NetMethodDefinition method)
{
// We can't really tell if the "Is" Prefix was omitted because of
// careless naming or because the chosen name is more to the point.
// http://docstore.mik.ua/orelly/java-ent/jnut/ch06_02.htm
// http://stackoverflow.com/questions/5322648/for-a-boolean-field-what-is-the-naming-convention-for-its-getter-setter
// http://stackoverflow.com/questions/11941485/java-naming-convention-for-boolean-variable-names-writerenabled-vs-writerisenab
// http://stackoverflow.com/questions/4851337/setter-for-a-boolean-variable-named-like-isactive
//
// Also, not adding a prefix improves source code compatibility with Xamarin.Android.
return false;
//var excludedPrefixes = new[] { "Is", "Can", "Has", "Use" };
//var namePrefix = GetNamePrefix(name);
//return !excludedPrefixes.Contains(namePrefix);
}
public void RenameMethodOnly(NetMethodDefinition method, string newName)
{
method.SetName(newName);
}
/// <summary>
/// Find the first matching set method.
/// </summary>
protected virtual NetMethodDefinition FindSetter(NetMethodDefinition getMethod, IEnumerable<NetMethodDefinition> setters, bool findOverriden=false)
{
var getName = getMethod.Name;
var getPrefix = GetNamePrefix(getName);
if (getPrefix == "Has" || getPrefix == "Can")
return null;
if(getPrefix != null)
getName = getName.Substring(getPrefix.Length);
var possibleSetterNames = new List<string>
{
"Set" + getName,
"set_" + getName
};
if (findOverriden && getPrefix == "get_")
{
// We need special handling for previously imported getters
// to handle everything that might have been done to them in
// "GetPropertyName". E.g. for get_IsEnabled, we want to find
// "SetEnabled" as well. This might be a hack.
if(getName.StartsWith("Is"))
possibleSetterNames.Add("Set" + getName.Substring(2));
else if (getName.StartsWith("_"))
possibleSetterNames.Add("Set" + getName.Substring(1));
}
var type = getMethod.ReturnType;
var possibleMatch = setters.Where(x => possibleSetterNames.Contains(x.Name)
&& x.Parameters[0].ParameterType.AreSame(type)
&& x.InterfaceType.AreSame(getMethod.InterfaceType)
&& x.HasSameVisibility(getMethod))
.ToList();
if (possibleMatch.Count > 1)
{
// try matching by create reason.
var singleForSameReason = possibleMatch.SingleOrDefault(s => s.CreateReason == getMethod.CreateReason);
if (singleForSameReason != null)
return singleForSameReason;
Console.Error.WriteLine("Warning: more than one possible setter matches property {0}::{1}. Not generating setter.", typeDef.FullName, getMethod.Name);
return null;
}
return possibleMatch.FirstOrDefault();
}
/// <summary>
/// Are the two methods equal wrt name, parameters and type parameter count?
/// </summary>
internal static bool IsDuplicate(this NetMethodDefinition method1, NetMethodDefinition method2)
{
if (method1.Name != method2.Name)
return false;
if (method1.IsSignConverted != method2.IsSignConverted)
return false;
var count = method1.Parameters.Count;
if (count != method2.Parameters.Count)
return false;
if (method1.GenericParameters.Count != method2.GenericParameters.Count)
return false;
for (var i = 0; i < count; i++)
{
if (!method1.Parameters[i].ParameterType.AreSame(method2.Parameters[i].ParameterType))
return false;
}
return true;
}
/// <summary>
/// Create a property name from the given getter.
/// </summary>
protected virtual string GetPropertyName(NetMethodDefinition method)
{
var name = method.Name;
bool isSetter = method.Name.StartsWith("Set") || method.Name.StartsWith("set_");
name = name.StartsWith("get_") ? name.Substring(4)
: name.StartsWith("Get") ? name.Substring(3)
: name.StartsWith("set_") ? name.Substring(4)
: name.StartsWith("Set") ? name.Substring(3)
: name;
bool isBool = (isSetter ? method.Parameters[0].ParameterType : method.ReturnType)
.IsBoolean();
if (isBool && AddIsPrefixToBoolProperty(name, method))
{
name = "Is" + name;
}
if (!(char.IsLetter(name[0]) || (name[0] == '_')))
name = "_" + name;
return name;
}
/// <summary>
/// Is the given method a property get method?
/// </summary>
protected override bool IsGetter(NetMethodDefinition method)
{
var name = method.Name;
if ((name == "Capacity") && (method.Parameters.Count == 0))
return true;
return base.IsGetter(method);
}
/// <summary>
/// Create a property name from the given getter.
/// </summary>
protected virtual string GetPropertyName(NetMethodDefinition getter)
{
var name = getter.Name;
name = name.StartsWith("Get") ? name.Substring(3) : name;
if (!(char.IsLetter(name[0]) || (name[0] == '_')))
name = "_" + name;
if (getter.ReturnType.IsBoolean() && !name.StartsWith("Is"))
name = "Is" + name;
return name;
}
