public EqualsHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation) :
     base(method, headers, implementation)
 {
     ObjCSignature = "isEqual:(id _Nullable)other";
     MonoSignature = "Equals(object)";
     ReturnType    = "bool";
 }
 public HashHelper(ProcessedMethod method, SourceWriter headers, SourceWriter implementation) :
     base(method, headers, implementation)
 {
     MonoSignature = "GetHashCode()";
     ObjCSignature = "hash";
     ReturnType    = "NSUInteger";
 }
Exemple #3
0
 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.GetParameters().Length);
                if (nameOverride != null)
                {
                    processedMethod.NameOverride = nameOverride;
                }
            }
        }
        public ProcessedProperty(PropertyInfo property, Processor processor) : base(processor)
        {
            Property = property;

            var g = Property.GetGetMethod();

            if (g != null)
            {
                GetMethod = new ProcessedMethod(g, Processor);
            }

            var s = Property.GetSetMethod();

            if (s != null)
            {
                SetMethod = new ProcessedMethod(s, Processor);
            }
        }
        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);
            }
        }
Exemple #8
0
        void ProcessPotentialName(ProcessedMethod processedMethod)
        {
            MethodInfo method = processedMethod.Method;

            if (IsOperatorOrFriendlyVersion(method))
            {
                string nameOverride = OperatorOverloads.GetObjCName(processedMethod.Method.Name, processedMethod.Method.GetParameters().Length);
                if (nameOverride != null)
                {
                    processedMethod.NameOverride = nameOverride;
                }
            }

            string objCSignature = processedMethod.ObjCSignature;

            if (RestrictedObjSelectors.IsImportantSelector(objCSignature))
            {
                string newName = "managed" + method.Name.PascalCase();
                processedMethod.NameOverride = newName;
                Delayed.Add(ErrorHelper.CreateWarning(1051, $"Element {method.Name} is generated instead as {newName} because its name conflicts with an important objective-c selector."));
            }
        }
Exemple #9
0
 protected abstract void Generate(ProcessedMethod method);