public HashHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation) :
base(method, headers, implementation)
{
MonoSignature = "GetHashCode()";
ObjCSignature = "hash";
ReturnType = "NSUInteger";
}
public EqualsHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation) :
base(method, headers, implementation)
{
ObjCSignature = "isEqual:(id _Nullable)other";
MonoSignature = "Equals(object)";
ReturnType = "bool";
}
protected IEnumerable <ProcessedMethod> PostProcessMethods(IEnumerable <MethodInfo> methods, IEnumerable <MethodInfo> equals)
{
HashSet <string> duplicateNames = FindDuplicateNames(methods);
HashSet <MethodInfo> operatorToIgnore = new HashSet <MethodInfo> (OperatorOverloads.FindOperatorPairToIgnore(methods, equals));
foreach (MethodInfo method in methods)
{
ProcessedMethod processedMethod = new ProcessedMethod(method);
if (duplicateNames.Contains(CreateStringRep(method)) && method.Name != "CompareTo") // HACK
{
processedMethod.FallBackToTypeName = true;
}
if (method.IsSpecialName && method.IsStatic && method.Name.StartsWith("op_", StringComparison.Ordinal))
{
processedMethod.IsOperator = true;
}
if (method.IsSpecialName && method.IsStatic && method.Name == "op_Equality")
{
processedMethod.NameOverride = "areEqual";
}
if (operatorToIgnore.Contains(method))
{
delayed.Add(ErrorHelper.CreateWarning(1033, $"Method {processedMethod.Method.Name} is not generated because another method exposes the operator with a friendly name"));
continue;
}
yield return(processedMethod);
}
}
protected override void Generate(ProcessedMethod method)
{
var objcsig = ImplementMethod(method.Method, method.BaseName, useTypeNames: method.FallBackToTypeName);
if (members_with_default_values.Contains(method.Method))
{
GenerateDefaultValuesWrappers(objcsig, method.Method);
}
}
public MethodHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation)
{
AssemblySafeName = method.DeclaringType.Assembly.SafeName;
MetadataToken = method.Method.MetadataToken;
ObjCTypeName = method.DeclaringType.ObjCName;
ManagedTypeName = method.DeclaringType.TypeName;
this.headers = headers;
this.implementation = implementation;
}
public EquatableHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation) :
base(method, headers, implementation)
{
ReturnType = "bool";
var pt = method.Method.GetParameters() [0].ParameterType;
var objc = NameGenerator.GetTypeName(pt);
var nullable = !pt.IsPrimitive ? " * _Nullable" : "";
ParameterType = pt;
ObjCSignature = $"isEqualTo{objc.PascalCase ()}:({objc}{nullable})other";
MonoSignature = $"Equals({NameGenerator.GetMonoName (pt)})";
}
void ProcessPotentialNameOverride(ProcessedMethod processedMethod)
{
MethodInfo method = processedMethod.Method;
if (IsOperatorOrFriendlyVersion(method))
{
string nameOverride = OperatorOverloads.GetObjCName(processedMethod.Method.Name, processedMethod.Method.ParameterCount);
if (nameOverride != null)
{
processedMethod.NameOverride = nameOverride;
}
}
}
IEnumerable <ProcessedMethod> AddDefaultValuesWrappers(MethodInfo mi)
{
// parameters with default values must be at the end and there can be many of them
var parameters = mi.GetParameters();
for (int i = parameters.Length - 1; i >= 0; i--)
{
if (!parameters [i].HasDefaultValue)
{
continue;
}
var pm = new ProcessedMethod(mi, this)
{
MethodType = MethodType.DefaultValueWrapper,
FirstDefaultParameter = i,
};
yield return(pm);
}
}
