rename parameters

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch/Operator/Logical/BinaryOperation.cs

@@ -8,25 +8,29 @@ internal class BinaryOperation(ILogicalOperation left, LogicalBinaryOperator typ
     : ILogicalOperation
 {
     public bool IsApplicableForPlaceholder(string placeholderName)
-        => left.IsApplicableForPlaceholder(placeholderName) || right.IsApplicableForPlaceholder(placeholderName);
+    {
+        return left.IsApplicableForPlaceholder(placeholderName) || right.IsApplicableForPlaceholder(placeholderName);
+    }
 
     public bool Execute(ref IParsingContext context)
     {
-        var left1 = left.Execute(ref context);
-        var right1 = right.Execute(ref context);
+        var leftResult = left.Execute(ref context);
+        var rightResult = right.Execute(ref context);
 
         return type switch
         {
-            LogicalBinaryOperator.And => left1 && right1,
-            LogicalBinaryOperator.Or => left1 || right1,
-            LogicalBinaryOperator.NAND => !(left1 && right1),
-            LogicalBinaryOperator.NOR => !(left1 || right1),
-            LogicalBinaryOperator.XOR => left1 ^ right1,
-            LogicalBinaryOperator.XNOR => left1 == right1,
+            LogicalBinaryOperator.And => leftResult && rightResult,
+            LogicalBinaryOperator.Or => leftResult || rightResult,
+            LogicalBinaryOperator.NAND => !(leftResult && rightResult),
+            LogicalBinaryOperator.NOR => !(leftResult || rightResult),
+            LogicalBinaryOperator.XOR => leftResult ^ rightResult,
+            LogicalBinaryOperator.XNOR => leftResult == rightResult,
             _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
         };
     }
 
     public override string ToString()
-        => $"{left}{Constant.Space}{type}{Constant.Space}{right}";
+    {
+        return $"{left}{Constant.Space}{type}{Constant.Space}{right}";
+    }
 }

src/SimpleStateMachine.StructuralSearch/Operator/Logical/InOperation.cs

@@ -8,23 +8,28 @@ namespace SimpleStateMachine.StructuralSearch.Operator.Logical;
 internal class InOperation(IParameter parameter, List<IParameter> arguments) : ILogicalOperation
 {
     public bool IsApplicableForPlaceholder(string placeholderName)
-        => parameter.IsApplicableForPlaceholder(placeholderName) || arguments.Any(a => a.IsApplicableForPlaceholder(placeholderName));
+    {
+        return parameter.IsApplicableForPlaceholder(placeholderName) ||
+               arguments.Any(a => a.IsApplicableForPlaceholder(placeholderName));
+    }
 
     public bool Execute(ref IParsingContext context)
     {
-        var parameter1 = parameter.GetValue(ref context);
+        var parameterValue = parameter.GetValue(ref context);
 
         foreach (var argument in arguments)
         {
             var value = argument.GetValue(ref context);
 
-            if (Equals(parameter1, value))
+            if (Equals(parameterValue, value))
                 return true;
         }
 
         return false;
     }
 
     public override string ToString()
-        => $"{parameter}{Constant.Space}{Constant.In}{Constant.Space}{string.Join(Constant.Comma, arguments)}";
+    {
+        return $"{parameter}{Constant.Space}{Constant.In}{Constant.Space}{string.Join(Constant.Comma, arguments)}";
+    }
 }

src/SimpleStateMachine.StructuralSearch/Operator/Logical/StringCompareOperation.cs

@@ -10,23 +10,27 @@ internal class StringCompareOperation(IParameter left, StringCompareOperator @op
     : ILogicalOperation
 {
     public bool IsApplicableForPlaceholder(string placeholderName)
-        => left.IsApplicableForPlaceholder(placeholderName) || right.IsApplicableForPlaceholder(placeholderName);
+    {
+        return left.IsApplicableForPlaceholder(placeholderName) || right.IsApplicableForPlaceholder(placeholderName);
+    }
 
     public bool Execute(ref IParsingContext context)
     {
-        var left1 = left.GetValue(ref context);
-        var right1 = right.GetValue(ref context);
+        var leftResult = left.GetValue(ref context);
+        var rightResult = right.GetValue(ref context);
 
         return @operator switch
         {
-            StringCompareOperator.Equals => left1.Equals(right1),
-            StringCompareOperator.Contains => left1.Contains(right1),
-            StringCompareOperator.StartsWith => left1.StartsWith(right1),
-            StringCompareOperator.EndsWith => left1.EndsWith(right1),
+            StringCompareOperator.Equals => leftResult.Equals(rightResult),
+            StringCompareOperator.Contains => leftResult.Contains(rightResult),
+            StringCompareOperator.StartsWith => leftResult.StartsWith(rightResult),
+            StringCompareOperator.EndsWith => leftResult.EndsWith(rightResult),
             _ => throw new ArgumentOutOfRangeException(nameof(@operator).FormatPrivateVar(), @operator, null)
         };
     }
 
     public override string ToString()
-        => $"{left}{Constant.Space}{@operator}{Constant.Space}{right}";
+    {
+        return $"{left}{Constant.Space}{@operator}{Constant.Space}{right}";
+    }
 }

src/SimpleStateMachine.StructuralSearch/Operator/String/StringUnaryParameter.cs

@@ -9,22 +9,27 @@ namespace SimpleStateMachine.StructuralSearch.Operator.String;
 internal class StringUnaryParameter(IParameter parameter, StringUnaryOperator type) : IParameter
 {
     public bool IsApplicableForPlaceholder(string placeholderName)
-        => parameter.IsApplicableForPlaceholder(placeholderName);
+    {
+        return parameter.IsApplicableForPlaceholder(placeholderName);
+    }
 
     public string GetValue(ref IParsingContext context)
     {
-        var parameter1 = parameter.GetValue(ref context);
+        var parameterValue = parameter.GetValue(ref context);
+
         return type switch
         {
-            StringUnaryOperator.Trim => parameter1.Trim(),
-            StringUnaryOperator.TrimEnd => parameter1.TrimEnd(),
-            StringUnaryOperator.TrimStart => parameter1.TrimStart(),
-            StringUnaryOperator.ToUpper => parameter1.ToUpper(),
-            StringUnaryOperator.ToLower => parameter1.ToLower(),
+            StringUnaryOperator.Trim => parameterValue.Trim(),
+            StringUnaryOperator.TrimEnd => parameterValue.TrimEnd(),
+            StringUnaryOperator.TrimStart => parameterValue.TrimStart(),
+            StringUnaryOperator.ToUpper => parameterValue.ToUpper(),
+            StringUnaryOperator.ToLower => parameterValue.ToLower(),
             _ => throw new ArgumentOutOfRangeException(nameof(type).FormatPrivateVar(), type, null)
         };
     }
 
     public override string ToString()
-        => $"{parameter}{Constant.Dote}{type}";
+    {
+        return $"{parameter}{Constant.Dote}{type}";
+    }
 }