Example #1
0
        public ConditionExpression Parse()
        {
            TrimAllSpaces();

            PriorityOperator priorityOp = null;

            ParseParentheses();

            // str start and end with the same parenthese closure
            while (m_parentheses.ContainsKey(0) &&
                   m_parentheses[0] == String.Length - 1)
            {
                // then we delete them, they are useless
                String = String.Remove(String.Length - 1, 1).Remove(0, 1);

                if (priorityOp != null)
                {
                    priorityOp.Expression = new PriorityOperator();
                    priorityOp            = priorityOp.Expression as PriorityOperator;
                }
                else
                {
                    priorityOp = new PriorityOperator();
                }

                ParseParentheses();
            }

            var boolOp = TryParseBoolOperator();

            if (boolOp != null)
            {
                if (priorityOp != null)
                {
                    priorityOp.Expression = boolOp;
                    return(priorityOp);
                }

                return(boolOp);
            }

            var compOp = TryParseComparaisonOperator();

            if (compOp == null)
            {
                throw new Exception(string.Format("Cannot parse {0} : No operator found", String));
            }

            if (priorityOp != null)
            {
                priorityOp.Expression = compOp;
                return(priorityOp);
            }

            return(compOp);
        }
Example #2
0
        public ConditionExpression Parse()
        {
            this.TrimAllSpaces();
            PriorityOperator priorityOperator = null;

            this.ParseParentheses();
            while (this.m_parentheses.ContainsKey(0) && this.m_parentheses[0] == this.String.Length - 1)
            {
                this.String = this.String.Remove(this.String.Length - 1, 1).Remove(0, 1);
                if (priorityOperator != null)
                {
                    priorityOperator.Expression = new PriorityOperator();
                    priorityOperator            = (priorityOperator.Expression as PriorityOperator);
                }
                else
                {
                    priorityOperator = new PriorityOperator();
                }
                this.ParseParentheses();
            }
            ConditionExpression conditionExpression = this.TryParseBoolOperator();
            ConditionExpression result;

            if (conditionExpression != null)
            {
                if (priorityOperator != null)
                {
                    priorityOperator.Expression = conditionExpression;
                    result = priorityOperator;
                }
                else
                {
                    result = conditionExpression;
                }
            }
            else
            {
                ConditionExpression conditionExpression2 = this.TryParseComparaisonOperator();
                if (conditionExpression2 == null)
                {
                    throw new System.Exception(string.Format("Cannot parse {0} : No operator found", this.String));
                }
                if (priorityOperator != null)
                {
                    priorityOperator.Expression = conditionExpression2;
                    result = priorityOperator;
                }
                else
                {
                    result = conditionExpression2;
                }
            }
            return(result);
        }