public Condition(bool not, string key, Operators opt,  params object[] values)
 {
     Key = key;
     Operate = opt;
     Values = values;
     Not = not;
 }

 internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, Operators op) {
     if (op == Operators.None) {
         return ag.AddDebugInfoAndVoid(
             Binders.Set(
                 ag.BinderState,
                 typeof(object),
                 SymbolTable.IdToString(_name),
                 ag.Transform(_target),
                 right
             ),
             span
         );
     } else {
         MSAst.ParameterExpression temp = ag.GetTemporary("inplace");
         return ag.AddDebugInfo(
             Ast.Block(
                 Ast.Assign(temp, ag.Transform(_target)),
                 SetMemberOperator(ag, right, op, temp),
                 Ast.Empty()
             ),
             Span.Start,
             span.End
         );
     }
 }

 public Rule(Operators operand, string to, string operandOne, string operandTwo)
 {
     this.Operation = operand;
     this.To = to;
     this.First = operandOne;
     this.Second = operandTwo;
 }

        internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, Operators op) {
            MSAst.Expression variable = _reference.Variable;
            MSAst.Expression assignment;

            Type vt = variable != null ? variable.Type : typeof(object);

            if (op != Operators.None) {
                right = Binders.Operation(
                    ag.BinderState,
                    vt,
                    StandardOperators.FromOperator(op),
                    Transform(ag, vt),
                    right
                );
            }

            if (variable != null) {
                assignment = AstUtils.Assign(variable, AstGenerator.ConvertIfNeeded(right, variable.Type));
            } else {
                assignment = AstUtils.Assign(_name, right);
            }

            SourceSpan aspan = span.IsValid ? new SourceSpan(Span.Start, span.End) : SourceSpan.None;
            return ag.AddDebugInfoAndVoid(assignment, aspan);
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                ViewState.Clear();
                this.result = 0;
                ViewState.Add("result", this.result);
                this.currentOperator = Operators.Plus;
                ViewState.Add("operator", this.currentOperator);
                ViewState.Add("currentNumber", string.Empty);
            }
            else
            {
                this.result = (decimal)ViewState["result"];
                if (ViewState["operator"] != null)
                {
                    this.currentOperator = (Operators)ViewState["operator"];
                }

                if (ViewState["currentNumber"] != null)
                {
                    this.currentNumber = (string)ViewState["currentNumber"];
                }

            }
        }

 public Expression(Expression ex, Expression e2, Operators op)
 {
     Ex1 = ex;
     Ex2 = e2;
     Oper = op;
     IsValue = false;
 }

 public FloatCondition(string conditionVariable, Operators conditionOperator, float baseValue, bool absolute = false)
 {
     this.conditionVariable = conditionVariable;
       this.conditionOperator = conditionOperator;
       this.baseValue = baseValue;
       this.absolute = absolute;
 }

        private static async void QuerySpecific(string field, object value, Operators op)
        {
            Console.WriteLine("Finding all the entries where {0} equals {1}...", field, value);
            var collection = database.GetCollection<BsonDocument>(collectionName);
            var builder = Builders<BsonDocument>.Filter;
            FilterDefinition<BsonDocument> filter = null;
            switch (op)
            {
                case Operators.Equals:
                default:
                    filter = builder.Eq(field, value);
                    break;
                case Operators.LessThan:
                    filter = builder.Lt(field, value);
                    break;
                case Operators.GreaterThan:
                    filter = builder.Gt(field, value);
                    break;
                case Operators.LessThanEqual:
                    filter = builder.Lte(field, value);
                    break;
                case Operators.GreaterThanEqual:
                    filter = builder.Gte(field, value);
                    break;
            }

            var result = await collection.Find(filter).ToListAsync();
            Console.WriteLine("There are {0} entries.", result.Count);
        }

 public void DoOperation(Operators @operator, int operand)
 {
     Executor command = new Executor(_calculator, @operator, operand);
     command.Execute();
     _index = _entries.Count;
     _index++;
     _entries.Add(command);
 }

        internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, Operators op) {
            if (Items.Length == 0) {
                ag.AddError("can't assign to ()", Span);
                return null;
            }

            return base.TransformSet(ag, span, right, op);
        }

 public static string FromOperator(Operators op) {
     switch(op) {
         case Operators.Equals: return "Equal";
         case Operators.NotEquals: return "NotEqual";
         default:
             return op.ToString();
     }
 }

 private Operators GetOpposite(Operators @operator)
 {
     switch (@operator)
     {
         case Operators.Add: return Operators.Rest;
         case Operators.Rest: return Operators.Add;
         case Operators.Mult: return Operators.Div;
         default: return Operators.Mult;
     }
 }

 private char GetSymbol(Operators @operator)
 {
     switch (@operator)
     {
         case Operators.Add: return '+';
         case Operators.Rest: return '-';
         case Operators.Mult: return '*';
         default: return '/';
     }
 }

 private void BuildConditionFromXML(XmlElement xmlElement)
 {
     try
     {
         this.FieldName = xmlElement.GetAttribute("Field");
         this.comparisionOperator = (Operators)Enum.Parse(typeof(Operators), xmlElement.GetAttribute("Operator"));
         this.strValue = xmlElement.GetAttribute("Value");
         this.comparisionType = (ConditionComparisionType)Enum.Parse(typeof(ConditionComparisionType), xmlElement.GetAttribute("ComparisionType"));
     }
     catch { }
 }

        internal FilterExpression(object left, object right, Operators op)
        {
            Left = left as FilterExpression;
            Right = right as FilterExpression;
            LeftColumn = left as Column;
            RightColumn = right as Column;
            Value = Right == null && ReferenceEquals(RightColumn, null) ? right : null;
            Operator = op;

            if (AndOr && (Left == null || Right == null)) // should never happen but just in case
                throw new Exception("All/Or expressions only act on two other FilterExpressions");
        }

 public static bool IsAssigmentOperator(Operators Operator)
 {
     switch (Operator)
     {
         case Operators.AssignmentAddition: 
         case Operators.AssignmentSubtraction: 
         case Operators.AssignmentMultiplication: 
         case Operators.AssignmentDivision: 
         case Operators.Assignment: return true;          
     }
     return false;
 }

    public JointConstraint( KinectWrapper.Joints joint_a,
							KinectWrapper.Joints joint_b,
							Relations relation,
							Operators operation,
							Vector3 val )
    {
        this.joint_a = joint_a;
        this.joint_b = joint_b;
        this.relation = relation;
        this.operation = operation;
        this.val = val;
    }

    public JointConstraint( KinectSkeleton ks,
							KinectSkeleton.Joints joint_a,
							KinectSkeleton.Joints joint_b,
							Relations relation,
							Operators operation,
							Vector3 val )
    {
        this.ks = ks;
        this.joint_a = joint_a;
        this.joint_b = joint_b;
        this.relation = relation;
        this.operation = operation;
        this.val = val;
    }

 static int _GetNumberOfChildrenFor(Operators symbol)
 {
     switch(symbol)
     {
         case Operators.Multiply:
         case Operators.Divide:
         case Operators.Plus:
         case Operators.Minus:
             return 2;
         case Operators.Sqrt:
             return 1;
         default:
             return 0;
     }
 }

 public void DoOperation(Operators @operator, int operand)
 {
     switch (@operator)
     {
         case Operators.Add: _total += operand;
             break;
         case Operators.Rest: _total -= operand;
             break;
         case Operators.Mult: _total *= operand;
             break;
         case Operators.Div: _total /= operand;
             break;
     }
     Console.WriteLine("Total: {0,3} \t{1} {2}",
         _total, GetSymbol(@operator), operand);
 }