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