From 39a368894df9cf2d776170d6c9ccc87e5046e763 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Thu, 5 Nov 2015 03:45:27 +0200
Subject: [PATCH] Reformatted the extension methods for classes.
Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
src/AST/ClassExtensions.cs | 93 ++++++++++++++++++++------------------
1 file changed, 50 insertions(+), 43 deletions(-)
diff --git a/src/AST/ClassExtensions.cs b/src/AST/ClassExtensions.cs
index 5f41f94c..0cc9a6f3 100644
--- a/src/AST/ClassExtensions.cs
+++ b/src/AST/ClassExtensions.cs
@@ -7,38 +7,43 @@ namespace CppSharp.AST
{
public static class ClassExtensions
{
- public static IEnumerable<Method> FindOperator(this Class c, CXXOperatorKind kind)
+ public static IEnumerable<Method> FindOperator(this Class @class,
+ CXXOperatorKind kind)
{
- return c.Operators.Where(method => method.OperatorKind == kind);
+ return @class.Operators.Where(method => method.OperatorKind == kind);
}
- public static IEnumerable<Method> FindMethodByOriginalName(this Class c, string name)
+ public static IEnumerable<Method> FindMethodByOriginalName(this Class @class,
+ string name)
{
- return c.Methods.Where(method => method.OriginalName == name);
+ return @class.Methods.Where(method => method.OriginalName == name);
}
- public static IEnumerable<Variable> FindVariableByOriginalName(this Class c, string originalName)
+ public static IEnumerable<Variable> FindVariableByOriginalName(this Class @class,
+ string originalName)
{
- return c.Variables.Where(v => v.OriginalName == originalName);
+ return @class.Variables.Where(v => v.OriginalName == originalName);
}
- public static IEnumerable<Function> GetFunctionOverloads(this Class c, Function function)
+ public static IEnumerable<Function> GetFunctionOverloads(this Class @class,
+ Function function)
{
if (function.IsOperator)
- return c.FindOperator(function.OperatorKind);
- return c.Methods.Where(method => method.Name == function.Name);
+ return @class.FindOperator(function.OperatorKind);
+ return @class.Methods.Where(method => method.Name == function.Name);
}
- public static IEnumerable<T> FindHierarchy<T>(this Class c, Func<Class, IEnumerable<T>> func)
+ public static IEnumerable<T> FindHierarchy<T>(this Class @class,
+ Func<Class, IEnumerable<T>> func)
where T : Declaration
{
- foreach (var elem in func(c))
+ foreach (var elem in func(@class))
yield return elem;
- foreach (var @base in c.Bases)
+ foreach (var @base in @class.Bases)
{
if (!@base.IsClass) continue;
- foreach(var elem in @base.Class.FindHierarchy<T>(func))
+ foreach(var elem in @base.Class.FindHierarchy(func))
yield return elem;
}
}
@@ -54,25 +59,25 @@ namespace CppSharp.AST
}
}
- public static Method GetBaseMethod(this Class c, Method @override, bool onlyPrimaryBase = false, bool getTopmost = false)
+ public static Method GetBaseMethod(this Class @class, Method @override,
+ bool onlyPrimaryBase = false, bool getTopmost = false)
{
- foreach (var @base in c.Bases)
+ var parameterTypeComparer = new ParameterTypeComparer();
+ foreach (var @base in @class.Bases.Where(
+ b => b.IsClass && b.Class.OriginalClass != @class && (!onlyPrimaryBase || !b.Class.IsInterface)))
{
- if (!@base.IsClass || @base.Class.OriginalClass == c || (onlyPrimaryBase && @base.Class.IsInterface))
- continue;
-
Method baseMethod;
if (!getTopmost)
{
- baseMethod = (@base.Class.GetBaseMethod(@override, onlyPrimaryBase));
+ baseMethod = @base.Class.GetBaseMethod(@override, onlyPrimaryBase);
if (baseMethod != null)
return baseMethod;
}
baseMethod = (from method in @base.Class.Methods
- where
- (method.OriginalName == @override.OriginalName && method.ReturnType == @override.ReturnType &&
- method.Parameters.SequenceEqual(@override.Parameters, new ParameterTypeComparer())) ||
+ where (method.OriginalName == @override.OriginalName &&
+ method.ReturnType == @override.ReturnType &&
+ method.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer)) ||
(@override.IsDestructor && method.IsDestructor && method.IsVirtual)
select method).FirstOrDefault();
if (baseMethod != null)
@@ -94,11 +99,14 @@ namespace CppSharp.AST
return baseMethod != null && !baseMethod.IsPure;
}
- public static Property GetBaseProperty(this Class c, Property @override, bool onlyFirstBase = false, bool getTopmost = false)
+ public static Property GetBaseProperty(this Class @class, Property @override,
+ bool onlyFirstBase = false, bool getTopmost = false)
{
- foreach (var @base in c.Bases)
+ var parameterTypeComparer = new ParameterTypeComparer();
+ foreach (var @base in @class.Bases)
{
- if (!@base.IsClass || @base.Class.OriginalClass == c || (onlyFirstBase && @base.Class.IsInterface))
+ if (!@base.IsClass || @base.Class.OriginalClass == @class ||
+ (onlyFirstBase && @base.Class.IsInterface))
continue;
Property baseProperty;
@@ -110,9 +118,8 @@ namespace CppSharp.AST
}
baseProperty = (from property in @base.Class.Properties
- where
- property.OriginalName == @override.OriginalName &&
- property.Parameters.SequenceEqual(@override.Parameters, new ParameterTypeComparer())
+ where property.OriginalName == @override.OriginalName &&
+ property.Parameters.SequenceEqual(@override.Parameters, parameterTypeComparer)
select property).FirstOrDefault();
if (baseProperty != null)
return baseProperty;
@@ -133,13 +140,13 @@ namespace CppSharp.AST
return baseProperty != null && !baseProperty.IsPure;
}
- public static Property GetPropertyByName(this Class c, string propertyName)
+ public static Property GetPropertyByName(this Class @class, string propertyName)
{
- Property property = c.Properties.FirstOrDefault(m => m.Name == propertyName);
+ Property property = @class.Properties.FirstOrDefault(m => m.Name == propertyName);
if (property != null)
return property;
- foreach (var baseClassSpecifier in c.Bases.Where(
+ foreach (var baseClassSpecifier in @class.Bases.Where(
b => b.Type.IsClass() && b.Class.IsDeclared))
{
property = baseClassSpecifier.Class.GetPropertyByName(propertyName);
@@ -149,16 +156,16 @@ namespace CppSharp.AST
return null;
}
- public static Property GetPropertyByConstituentMethod(this Class c, Method method)
+ public static Property GetPropertyByConstituentMethod(this Class @class, Method method)
{
- var property = c.Properties.FirstOrDefault(p => p.GetMethod == method);
+ var property = @class.Properties.FirstOrDefault(p => p.GetMethod == method);
if (property != null)
return property;
- property = c.Properties.FirstOrDefault(p => p.SetMethod == method);
+ property = @class.Properties.FirstOrDefault(p => p.SetMethod == method);
if (property != null)
return property;
- foreach (BaseClassSpecifier @base in c.Bases.Where(b => b.Type.IsClass()))
+ foreach (BaseClassSpecifier @base in @class.Bases.Where(b => b.Type.IsClass()))
{
property = @base.Class.GetPropertyByConstituentMethod(method);
if (property != null)
@@ -167,13 +174,13 @@ namespace CppSharp.AST
return null;
}
- public static Method GetMethodByName(this Class c, string methodName)
+ public static Method GetMethodByName(this Class @class, string methodName)
{
- var method = c.Methods.FirstOrDefault(m => m.Name == methodName);
+ var method = @class.Methods.FirstOrDefault(m => m.Name == methodName);
if (method != null)
return method;
- foreach (BaseClassSpecifier @base in c.Bases.Where(b => b.Type.IsClass()))
+ foreach (var @base in @class.Bases.Where(b => b.Type.IsClass()))
{
method = @base.Class.GetMethodByName(methodName);
if (method != null)
@@ -184,18 +191,18 @@ namespace CppSharp.AST
public static bool HasRefBase(this Class @class)
{
- Class baseClass = null;
+ Class @base = null;
if (@class.HasBaseClass)
- baseClass = @class.Bases[0].Class;
+ @base = @class.Bases[0].Class;
- var hasRefBase = baseClass != null && baseClass.IsRefType
- && baseClass.IsDeclared;
+ var hasRefBase = @base != null && @base.IsRefType && @base.IsDeclared;
return hasRefBase;
}
- private static bool ComputeClassPath(this Class current, Class target, IList<BaseClassSpecifier> path)
+ private static bool ComputeClassPath(this Class current, Class target,
+ IList<BaseClassSpecifier> path)
{
if (target == current)
return true;