C# (CSharp) NCalc.Domain BinaryExpressionの例

コード例 #1

ファイル: EvaluationVisitor.cs プロジェクト: EmptyCubes/More

        public override void Visit(BinaryExpression expression)
        {
            // simulate Lazy<Func<>> behavior for late evaluation
            object leftValue = null;
            Func<object> left = () =>
                                 {
                                     if (leftValue == null)
                                     {
                                         expression.LeftExpression.Accept(this);
                                         leftValue = Result;
                                     }
                                     return leftValue;
                                 };

            // simulate Lazy<Func<>> behavior for late evaluation
            object rightValue = null;
            Func<object> right = () =>
            {
                if (rightValue == null)
                {
                    expression.RightExpression.Accept(this);
                    rightValue = Result;
                }
                return rightValue;
            };

            switch (expression.Type)
            {
                case BinaryExpressionType.And:
                    Result = Convert.ToBoolean(left()) && Convert.ToBoolean(right());
                    break;

                case BinaryExpressionType.Or:
                    Result = Convert.ToBoolean(left()) || Convert.ToBoolean(right());
                    break;

                case BinaryExpressionType.Div:
                    Result = IsReal(left()) || IsReal(right())
                                 ? Numbers.Divide(left(), right())
                                 : Numbers.Divide(Convert.ToDouble(left()), right());
                    break;

                case BinaryExpressionType.Equal:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) == 0;
                    break;

                case BinaryExpressionType.Greater:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) > 0;
                    break;

                case BinaryExpressionType.GreaterOrEqual:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) >= 0;
                    break;

                case BinaryExpressionType.Lesser:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) < 0;
                    break;

                case BinaryExpressionType.LesserOrEqual:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) <= 0;
                    break;

                case BinaryExpressionType.Minus:
                    Result = Numbers.Soustract(left(), right());
                    break;

                case BinaryExpressionType.Modulo:
                    Result = Numbers.Modulo(left(), right());
                    break;

                case BinaryExpressionType.NotEqual:
                    // Use the type of the left operand to make the comparison
                    Result = CompareUsingMostPreciseType(left(), right()) != 0;
                    break;

                case BinaryExpressionType.Plus:
                    if (left() is string)
                    {
                        Result = String.Concat(left(), right());
                    }
                    else
                    {
                        Result = Numbers.Add(left(), right());
                    }

                    break;

                case BinaryExpressionType.Times:
                    Result = Numbers.Multiply(left(), right());
                    break;

                case BinaryExpressionType.BitwiseAnd:
                    Result = Convert.ToUInt16(left()) & Convert.ToUInt16(right());
                    break;

                case BinaryExpressionType.BitwiseOr:
                    Result = Convert.ToUInt16(left()) | Convert.ToUInt16(right());
                    break;

                case BinaryExpressionType.BitwiseXOr:
                    Result = Convert.ToUInt16(left()) ^ Convert.ToUInt16(right());
                    break;

                case BinaryExpressionType.LeftShift:
                    Result = Convert.ToUInt16(left()) << Convert.ToUInt16(right());
                    break;

                case BinaryExpressionType.RightShift:
                    Result = Convert.ToUInt16(left()) >> Convert.ToUInt16(right());
                    break;
            }
        }

コード例 #2

ファイル: SerializationVisitor.cs プロジェクト: tvrc1990/BF

        public override void Visit(BinaryExpression expression)
        {
            EncapsulateNoValue(expression.LeftExpression);

            switch (expression.Type)
            {
                case BinaryExpressionType.And:
                    Result.Append("and ");
                    break;

                case BinaryExpressionType.Or:
                    Result.Append("or ");
                    break;

                case BinaryExpressionType.Div:
                    Result.Append("/ ");
                    break;

                case BinaryExpressionType.Equal:
                    Result.Append("= ");
                    break;

                case BinaryExpressionType.Greater:
                    Result.Append("> ");
                    break;

                case BinaryExpressionType.GreaterOrEqual:
                    Result.Append(">= ");
                    break;

                case BinaryExpressionType.Lesser:
                    Result.Append("< ");
                    break;

                case BinaryExpressionType.LesserOrEqual:
                    Result.Append("<= ");
                    break;

                case BinaryExpressionType.Minus:
                    Result.Append("- ");
                    break;

                case BinaryExpressionType.Modulo:
                    Result.Append("% ");
                    break;

                case BinaryExpressionType.NotEqual:
                    Result.Append("!= ");
                    break;

                case BinaryExpressionType.Plus:
                    Result.Append("+ ");
                    break;

                case BinaryExpressionType.Times:
                    Result.Append("* ");
                    break;

                case BinaryExpressionType.BitwiseAnd:
                    Result.Append("& ");
                    break;

                case BinaryExpressionType.BitwiseOr:
                    Result.Append("| ");
                    break;

                case BinaryExpressionType.BitwiseXOr:
                    Result.Append("~ ");
                    break;

                case BinaryExpressionType.LeftShift:
                    Result.Append("<< ");
                    break;

                case BinaryExpressionType.RightShift:
                    Result.Append(">> ");
                    break;
            }

            EncapsulateNoValue(expression.RightExpression);
        }

コード例 #3

 public override void Visit(NCalc.Domain.BinaryExpression expression)
 {
     //Visit left and right
     expression.LeftExpression.Accept(this);
     expression.RightExpression.Accept(this);
 }

コード例 #4

ファイル: ExplainSerializationVisitor.cs プロジェクト: EmptyCubes/More

        public override void Visit(BinaryExpression expression)
        {
            switch (expression.Type)
            {
                case BinaryExpressionType.And:
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append("AND ");
                    EncapsulateNoValue(expression.RightExpression);
                    break;

                case BinaryExpressionType.Or:
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append(" OR ");
                    EncapsulateNoValue(expression.RightExpression);
                    break;

                case BinaryExpressionType.Div:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("/ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Equal:
                    EncapsulateNoValue(expression.LeftExpression);
                    //Result.Append(".Equals(");
                    EncapsulateNoValue(expression.RightExpression);
                    // Result.Append(")");
                    break;

                case BinaryExpressionType.Greater:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("GREATER THAN ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.GreaterOrEqual:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("GREATER OR EQUAL TO ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Lesser:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("LESS THAN ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.LesserOrEqual:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("LESS THAN OR EQUAL TO ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Minus:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("- ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Modulo:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("% ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.NotEqual:

                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append("IS NOT EQUAL TO ");
                    EncapsulateNoValue(expression.RightExpression);

                    break;

                case BinaryExpressionType.Plus:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("+ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Times:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("* ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseAnd:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("& ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseOr:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("| ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseXOr:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("~ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.LeftShift:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("<< ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.RightShift:
                    Result.Append(">> ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;
            }
        }

コード例 #5

ファイル: CSharpSerializationVisitor.cs プロジェクト: EmptyCubes/More

        public override void Visit(BinaryExpression expression)
        {
            switch (expression.Type)
            {
                case BinaryExpressionType.And:

                    Result.Append("Convert.ToBoolean(");
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append(")");
                    Result.Append("&& ");
                    Result.Append("Convert.ToBoolean(");
                    EncapsulateNoValue(expression.RightExpression);
                    Result.Append(")");
                    break;

                case BinaryExpressionType.Or:
                    Result.Append("Convert.ToBoolean(");
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append(")");
                    Result.Append("|| ");
                    Result.Append("Convert.ToBoolean(");
                    EncapsulateNoValue(expression.RightExpression);
                    Result.Append(")");
                    break;

                case BinaryExpressionType.Div:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("/ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Equal:
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append(".Equals(");
                    EncapsulateNoValue(expression.RightExpression);
                    Result.Append(")");
                    break;

                case BinaryExpressionType.Greater:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("> ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.GreaterOrEqual:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append(">= ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Lesser:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("< ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.LesserOrEqual:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("<= ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Minus:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("- ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Modulo:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("% ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.NotEqual:
                    Result.Append("!(");
                    EncapsulateNoValue(expression.LeftExpression);
                    Result.Append(".Equals(");
                    EncapsulateNoValue(expression.RightExpression);
                    Result.Append("))");
                    break;

                case BinaryExpressionType.Plus:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("+ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.Times:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("* ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseAnd:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("& ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseOr:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("| ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.BitwiseXOr:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("~ ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.LeftShift:
                    EncapsulateNoValue("Convert.ToDouble", expression.LeftExpression);
                    Result.Append("<< ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;

                case BinaryExpressionType.RightShift:
                    Result.Append(">> ");
                    EncapsulateNoValue("Convert.ToDouble", expression.RightExpression);
                    break;
            }
        }

コード例 #6

ファイル: ParameterExtractionVisitor.cs プロジェクト: tumcms/TUM.CMS.VPLControl

 public override void Visit(BinaryExpression expression)
 {
     //Visit left and right
     expression.LeftExpression.Accept(this);
     expression.RightExpression.Accept(this);
 }

コード例 #7

ファイル: EvalExpression.cs プロジェクト: wflk/canape

 public override void Visit(NCalc.Domain.BinaryExpression expression)
 {
 }

コード例 #8

 public abstract Task VisitAsync(BinaryExpression expression);

コード例 #9

 public abstract void Visit(BinaryExpression expression);

コード例 #10

ファイル: EvaluationVisitor.cs プロジェクト: vksundaram/hrms

        public override void Visit(BinaryExpression expression)
        {
            // simulate Lazy<Func<>> behavior for late evaluation
            object        leftValue = null;
            Func <object> left      = () =>
            {
                if (leftValue == null)
                {
                    expression.LeftExpression.Accept(this);
                    leftValue = Result;
                }
                return(leftValue);
            };

            // simulate Lazy<Func<>> behavior for late evaluation
            object        rightValue = null;
            Func <object> right      = () =>
            {
                if (rightValue == null)
                {
                    expression.RightExpression.Accept(this);
                    rightValue = Result;
                }
                return(rightValue);
            };

            switch (expression.Type)
            {
            case BinaryExpressionType.And:
                Result = Convert.ToBoolean(left()) && Convert.ToBoolean(right());
                break;

            case BinaryExpressionType.Or:
                Result = Convert.ToBoolean(left()) || Convert.ToBoolean(right());
                break;

            case BinaryExpressionType.Div:
                Result = IsReal(left()) || IsReal(right())
                                 ? Numbers.Divide(left(), right())
                                 : Numbers.Divide(Convert.ToDouble(left()), right());
                break;

            case BinaryExpressionType.Equal:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) == 0;
                break;

            case BinaryExpressionType.Greater:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) > 0;
                break;

            case BinaryExpressionType.GreaterOrEqual:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) >= 0;
                break;

            case BinaryExpressionType.Lesser:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) < 0;
                break;

            case BinaryExpressionType.LesserOrEqual:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) <= 0;
                break;

            case BinaryExpressionType.Minus:
                Result = Numbers.Soustract(left(), right());
                break;

            case BinaryExpressionType.Modulo:
                Result = Numbers.Modulo(left(), right());
                break;

            case BinaryExpressionType.NotEqual:
                // Use the type of the left operand to make the comparison
                Result = CompareUsingMostPreciseType(left(), right()) != 0;
                break;

            case BinaryExpressionType.Plus:
                if (left() is string)
                {
                    Result = String.Concat(left(), right());
                }
                else
                {
                    Result = Numbers.Add(left(), right());
                }

                break;

            case BinaryExpressionType.Times:
                Result = Numbers.Multiply(left(), right());
                break;

            case BinaryExpressionType.BitwiseAnd:
                Result = Convert.ToUInt16(left()) & Convert.ToUInt16(right());
                break;

            case BinaryExpressionType.BitwiseOr:
                Result = Convert.ToUInt16(left()) | Convert.ToUInt16(right());
                break;

            case BinaryExpressionType.BitwiseXOr:
                Result = Convert.ToUInt16(left()) ^ Convert.ToUInt16(right());
                break;

            case BinaryExpressionType.LeftShift:
                Result = Convert.ToUInt16(left()) << Convert.ToUInt16(right());
                break;

            case BinaryExpressionType.RightShift:
                Result = Convert.ToUInt16(left()) >> Convert.ToUInt16(right());
                break;
            }
        }

コード例 #11

ファイル: SerializationVisitor.cs プロジェクト: dendyliu/REvan-2.0

        public override void Visit(BinaryExpression expression)
        {
            EncapsulateNoValue(expression.LeftExpression);

            switch (expression.Type)
            {
            case BinaryExpressionType.And:
                Result.Append("and ");
                break;

            case BinaryExpressionType.Or:
                Result.Append("or ");
                break;

            case BinaryExpressionType.Div:
                Result.Append("/ ");
                break;

            case BinaryExpressionType.Equal:
                Result.Append("= ");
                break;

            case BinaryExpressionType.Greater:
                Result.Append("> ");
                break;

            case BinaryExpressionType.GreaterOrEqual:
                Result.Append(">= ");
                break;

            case BinaryExpressionType.Lesser:
                Result.Append("< ");
                break;

            case BinaryExpressionType.LesserOrEqual:
                Result.Append("<= ");
                break;

            case BinaryExpressionType.Minus:
                Result.Append("- ");
                break;

            case BinaryExpressionType.Modulo:
                Result.Append("% ");
                break;

            case BinaryExpressionType.NotEqual:
                Result.Append("!= ");
                break;

            case BinaryExpressionType.Plus:
                Result.Append("+ ");
                break;

            case BinaryExpressionType.Times:
                Result.Append("* ");
                break;

            case BinaryExpressionType.BitwiseAnd:
                Result.Append("& ");
                break;

            case BinaryExpressionType.BitwiseOr:
                Result.Append("| ");
                break;

            case BinaryExpressionType.BitwiseXOr:
                Result.Append("~ ");
                break;

            case BinaryExpressionType.LeftShift:
                Result.Append("<< ");
                break;

            case BinaryExpressionType.RightShift:
                Result.Append(">> ");
                break;
            }

            EncapsulateNoValue(expression.RightExpression);
        }