From a5a17a493ef45df3d9426cfac08d6381b04c32dc Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Thu, 19 Nov 2015 19:17:10 +0200 Subject: [PATCH] Changed the comparer for parameter types to a singleton. The class has no fields so the same value was allocated many times, it was wasteful. Signed-off-by: Dimitar Dobrev --- src/AST/ClassExtensions.cs | 7 +++---- src/AST/Function.cs | 6 ++++++ src/AST/FunctionExtensions.cs | 6 ++---- src/Generator/Passes/CheckAmbiguousFunctions.cs | 10 +++++----- .../Passes/GenerateAbstractImplementationsPass.cs | 3 +-- src/Generator/Passes/GenerateAnonymousDelegatesPass.cs | 4 ++-- src/Generator/Passes/MultipleInheritancePass.cs | 3 +-- 7 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/AST/ClassExtensions.cs b/src/AST/ClassExtensions.cs index 1d5264ec..81a5a705 100644 --- a/src/AST/ClassExtensions.cs +++ b/src/AST/ClassExtensions.cs @@ -62,7 +62,6 @@ namespace CppSharp.AST public static Method GetBaseMethod(this Class @class, Method @override, bool onlyPrimaryBase = false, bool getTopmost = false) { - var parameterTypeComparer = new ParameterTypeComparer(); foreach (var @base in @class.Bases.Where( b => b.IsClass && b.Class.OriginalClass != @class && (!onlyPrimaryBase || !b.Class.IsInterface))) { @@ -75,7 +74,7 @@ namespace CppSharp.AST } baseMethod = (from method in @base.Class.Methods - where @override.CanOverride(method, parameterTypeComparer) + where @override.CanOverride(method) select method).FirstOrDefault(); if (baseMethod != null) return baseMethod; @@ -100,7 +99,6 @@ namespace CppSharp.AST public static Property GetBaseProperty(this Class @class, Property @override, bool onlyFirstBase = false, bool getTopmost = false) { - var parameterTypeComparer = new ParameterTypeComparer(); foreach (var @base in @class.Bases) { if (!@base.IsClass || @base.Class.OriginalClass == @class || @@ -117,7 +115,8 @@ namespace CppSharp.AST baseProperty = (from property in @base.Class.Properties where property.OriginalName == @override.OriginalName && - property.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer) + property.Parameters.SequenceEqual(@override.Parameters, + ParameterTypeComparer.Instance) select property).FirstOrDefault(); if (baseProperty != null) return baseProperty; diff --git a/src/AST/Function.cs b/src/AST/Function.cs index acf2d952..23605160 100644 --- a/src/AST/Function.cs +++ b/src/AST/Function.cs @@ -78,6 +78,12 @@ namespace CppSharp.AST public class ParameterTypeComparer : IEqualityComparer { + public static readonly ParameterTypeComparer Instance = new ParameterTypeComparer(); + + private ParameterTypeComparer() + { + } + public bool Equals(Parameter x, Parameter y) { return x.QualifiedType == y.QualifiedType; diff --git a/src/AST/FunctionExtensions.cs b/src/AST/FunctionExtensions.cs index f5462cb3..29bb4fbe 100644 --- a/src/AST/FunctionExtensions.cs +++ b/src/AST/FunctionExtensions.cs @@ -73,13 +73,11 @@ namespace CppSharp.AST return @params; } - public static bool CanOverride(this Method @override, Method method, - ParameterTypeComparer parameterTypeComparer = null) + public static bool CanOverride(this Method @override, Method method) { - parameterTypeComparer = parameterTypeComparer ?? new ParameterTypeComparer(); return (method.OriginalName == @override.OriginalName && method.ReturnType == @override.ReturnType && - method.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer)) || + method.Parameters.SequenceEqual(@override.Parameters, ParameterTypeComparer.Instance)) || (@override.IsDestructor && method.IsDestructor && method.IsVirtual); } } diff --git a/src/Generator/Passes/CheckAmbiguousFunctions.cs b/src/Generator/Passes/CheckAmbiguousFunctions.cs index 02272276..6ae4d594 100644 --- a/src/Generator/Passes/CheckAmbiguousFunctions.cs +++ b/src/Generator/Passes/CheckAmbiguousFunctions.cs @@ -98,12 +98,12 @@ namespace CppSharp.Passes private static bool CheckConstnessForAmbiguity(Function function, Function overload) { - if (function is Method && overload is Method) + var method1 = function as Method; + var method2 = overload as Method; + if (method1 != null && method2 != null) { - var method1 = function as Method; - var method2 = overload as Method; - - var sameParams = method1.Parameters.SequenceEqual(method2.Parameters, new ParameterTypeComparer()); + var sameParams = method1.Parameters.SequenceEqual(method2.Parameters, + ParameterTypeComparer.Instance); if (method1.IsConst && !method2.IsConst && sameParams) { diff --git a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs index b1d14155..450a662d 100644 --- a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs +++ b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs @@ -93,14 +93,13 @@ namespace CppSharp.Passes { var abstractMethods = GetAbstractMethods(@class); var overriddenMethods = GetOverriddenMethods(@class); - var paramTypeCmp = new ParameterTypeComparer(); for (var i = abstractMethods.Count - 1; i >= 0; i--) { var @abstract = abstractMethods[i]; var @override = overriddenMethods.Find(m => m.Name == @abstract.Name && m.ReturnType == @abstract.ReturnType && - m.Parameters.SequenceEqual(@abstract.Parameters, paramTypeCmp)); + m.Parameters.SequenceEqual(@abstract.Parameters, ParameterTypeComparer.Instance)); if (@override != null) { if (@abstract.IsOverride) diff --git a/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs b/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs index b0eaa90f..294298cf 100644 --- a/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs +++ b/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs @@ -114,12 +114,12 @@ namespace CppSharp.Passes /// The typedef list to search. /// The function to match. /// The matching typedef, or null if not found. - private TypedefDecl FindMatchingTypedef(List typedefs, FunctionType functionType) + private static TypedefDecl FindMatchingTypedef(IEnumerable typedefs, FunctionType functionType) { return (from typedef in typedefs let type = (FunctionType)typedef.Declaration.Type.GetPointee() where type.ReturnType == functionType.ReturnType && - type.Parameters.SequenceEqual(functionType.Parameters, new ParameterTypeComparer()) + type.Parameters.SequenceEqual(functionType.Parameters, ParameterTypeComparer.Instance) select typedef.Declaration).SingleOrDefault(); } } diff --git a/src/Generator/Passes/MultipleInheritancePass.cs b/src/Generator/Passes/MultipleInheritancePass.cs index 1205dec7..d7d41b71 100644 --- a/src/Generator/Passes/MultipleInheritancePass.cs +++ b/src/Generator/Passes/MultipleInheritancePass.cs @@ -146,12 +146,11 @@ namespace CppSharp.Passes private static void ImplementInterfaceMethods(Class @class, Class @interface) { - var parameterTypeComparer = new ParameterTypeComparer(); foreach (var method in @interface.Methods) { if (@class.Methods.Any(m => m.OriginalName == method.OriginalName && m.Parameters.SequenceEqual(method.Parameters.Where(p => !p.Ignore), - parameterTypeComparer))) + ParameterTypeComparer.Instance))) continue; var impl = new Method(method) {