public OperatorView(OperatorType type)
     : base(0, 0, 10, 10)
 {
     Type = type;
     LineWidth = 1;
     LineColor = new Color(0, 0, 0);
 }

 public PriceFilter(StockInfo stockInfo, OperatorType operatorType, PriceFilterRightOperandType rightOperandType,
     double? percent = null, double? constant = null)
     : base(stockInfo, operatorType, percent)
 {
     this.rightOperandType = rightOperandType;
     this.constant = constant;
 }

 /// <summary>
 ///   构造
 /// </summary>
 /// <param name = "fieldName">字段名</param>
 /// <param name = "operator">表达式操作符</param>
 /// <param name = "value">值</param>
 /// <param name = "nextUnionType">与下一个表达式的联合类型<see cref = "WhereUnionType" /></param>
 public FieldCondition(string fieldName, OperatorType @operator, object value, WhereUnionType @nextUnionType)
 {
     FieldName = fieldName;
     Operator = @operator;
     Value = value;
     NextUnionType = nextUnionType;
 }

        /// <summary>
        /// Returns .NET Expression type based on Operator Type
        /// </summary>
        /// <param name="opType"></param>
        /// <returns></returns>
        public static ExpressionType GetExpressionType(OperatorType opType)
        {
            ExpressionType exprType;
            
            switch ((OperatorType) opType )
            {
                case OperatorType.EqualsTo :  exprType = ExpressionType.Equal;
                    break;
                case OperatorType.NotEqualsTo: exprType = ExpressionType.NotEqual;
                    break;
                case OperatorType.GreaterThan: exprType = ExpressionType.GreaterThan;
                    break;
                case OperatorType.GreaterThanEqualsTo: exprType = ExpressionType.GreaterThanOrEqual;
                    break;
                case OperatorType.LessThan: exprType = ExpressionType.LessThan;
                    break;
                case OperatorType.LessThanEqualsTo: exprType = ExpressionType.LessThanOrEqual;
                    break;
                default: exprType = ExpressionType.IsFalse;
                    break;
            }

            return exprType;
            
        }

 public OperatorResolveResult(OperatorType @operator, TypeDefinition operatorType, params ResolveResult[] operands)
     : base(operatorType)
 {
     Operator = @operator;
     OperatorType = operatorType;
     Operands = new ReadOnlyCollection<ResolveResult>(operands);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="OperatorToken"/> class.
        /// </summary>
        /// <param name="op">The operator</param>
        public OperatorToken(OperatorType op)
        {
            Operator = op;
            Type = TokenType.Operator;

            switch (Operator)
            {
                case OperatorType.Plus:
                    Priority = 1;
                    break;
                case OperatorType.Minus:
                    Priority = 1;
                    break;
                case OperatorType.Mult:
                    Priority = 2;
                    break;
                case OperatorType.Div:
                    Priority = 2;
                    break;
                case OperatorType.LeftBraket:
                    Priority = 0;
                    break;
                case OperatorType.RightBraket:
                    break;
                default:
                    break;
            }
        }

 public OpSlot(string value, OperatorType type, int position)
     : this()
 {
     this.Value = value;
     this.Type = type;
     this.Position = position;
 }

        public static Operator CreateOpPostAssign(this Node lhs, OperatorType op, Node rhs)
        {
            var e_lhs = lhs as Expression;
            var e_rhs = rhs as Expression;
            if (e_lhs == null || e_rhs == null) return null;

            OperatorType opAssign;
            if (EnumHelper.TryParse(op + "Assign", out opAssign))
            {
                if (op == OperatorType.Add && e_rhs.IsConstOne())
                {
                    return Operator.PostIncrement(e_lhs);
                }
                else if (op == OperatorType.Subtract && e_rhs.IsConstOne())
                {
                    return Operator.PostDecrement(e_lhs);
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
        }

 /// <summary>
 /// parametru folosit in constructia HqlObject
 /// </summary>
 /// <example>memberName condition: paramName</example>
 /// <param name="paramName">numele parametrului folosit</param>
 /// <param name="paramValue">valoarea parametrului ce va fi inlocuit</param>
 /// <param name="memberName">membrul din query ce va fi comparat</param>
 /// <param name="condition">conditia de comparatie ('=', 'Like', etc)</param>
 public QueryParameter(string paramName, object paramValue, string memberName, OperatorType condition)
 {
     this.paramName = paramName;
     this.paramValue = paramValue;
     this.memberName = memberName;
     this.condition = condition;
 }

    public void ApplyCSG()
    {
        switch (operation) {
        case OperatorType.Union:
            temp = modeller.getUnion ();
            break;
        case OperatorType.Intersection:
            temp = modeller.getIntersection ();
            break;
        case OperatorType.Difference:
            temp = modeller.getDifference ();
            break;
        }

        // Apply to output game object
        CSGGameObject.GenerateMesh(output, ObjMaterial, temp);
        // Make sure the output object has its 'solid' updated
        output.GetComponent<CSGObject> ().GenerateSolid ();

        // Hide the original objects
        objectA.SetActive (false);
        objectB.SetActive (false);

        lasten = enableOperator;
        lastop = operation;
    }

 /// <summary>
 /// Gets the underlying base operator for the given compound operator.
 /// </summary>
 /// <param name="compoundOperatorType"> The type of compound operator. </param>
 /// <returns> The underlying base operator, or <c>null</c> if the type is not a compound
 /// operator. </returns>
 private static Operator GetCompoundBaseOperator(OperatorType compoundOperatorType)
 {
     switch (compoundOperatorType)
     {
         case OperatorType.CompoundAdd:
             return Operator.Add;
         case OperatorType.CompoundBitwiseAnd:
             return Operator.BitwiseAnd;
         case OperatorType.CompoundBitwiseOr:
             return Operator.BitwiseOr;
         case OperatorType.CompoundBitwiseXor:
             return Operator.BitwiseXor;
         case OperatorType.CompoundDivide:
             return Operator.Divide;
         case OperatorType.CompoundLeftShift:
             return Operator.LeftShift;
         case OperatorType.CompoundModulo:
             return Operator.Modulo;
         case OperatorType.CompoundMultiply:
             return Operator.Multiply;
         case OperatorType.CompoundSignedRightShift:
             return Operator.SignedRightShift;
         case OperatorType.CompoundSubtract:
             return Operator.Subtract;
         case OperatorType.CompoundUnsignedRightShift:
             return Operator.UnsignedRightShift;
     }
     return null;
 }

 /// <summary>
 /// Creates the condition based on it's region id, field, operator to evaluate to the value and whether it is case sensitive.
 /// </summary>
 /// <param name="regionid">The ID of the region.</param>
 /// <param name="field">The name of the field.</param>
 /// <param name="aValue">The value to match.</param>
 /// <param name="aOperator">The operator for the comparison.</param>
 /// <param name="casesensitive">Whether the value is matched with case sensitivity.</param>
 public Condition(string regionid, string field, string aValue, OperatorType aOperator, bool casesensitive)
 {
     this.RegionID = regionid;
     this.Field = field;
     this.Operator = aOperator;
     this.CaseSensitive = casesensitive;
     this.Value = aValue;
 }

 public Operator(string name, OperatorType type, int precedence, AssociationType association, Func<double, double, double> body)
     : base(name)
 {
     this.Type = type;
     this.Precedence = precedence;
     this.Association = association;
     this.Body = body;
 }

 public Token(OperatorType operatorType, int operandsCount, Associativity assoc)
 {
     this.Type = TokenType.Operator;
     this.OperatorType = operatorType;
     this.OperandsCount = operandsCount;
     this.Associativity = assoc;
     this.Precedence = GetPrecedence();
 }

 // if numDigits = 0, don't care how much space it takes up
 private NumberSprite(ContentManager Content, int number, int numDigits, ColorType color, OperatorType op)
 {
     this.Content = Content;
     this.number = number;
     this.numDigits = numDigits;
     this.color = color;
     this.op = op;
 }

        public Token(OperatorType opType, string text)
        {
            _type = TokenType.Operator;
            _opType = opType;
            _text = text;

            Initialize();
        }

 public Operator(string s, int p, string a, double v, OperatorType o)
 {
     str = s;
     precedence = p;
     associativity = a;
     value = v;
     opType = o;
 }

 private void SetDefaults(string className, OperatorType operatorType, DataElement m_dataLeft, bool createNewId)
 {
     m_className = className;
     m_operatorType = operatorType;
     if (null != m_dataLeft)
     {
         m_dataLeft = new DataElement(m_dataLeft, m_dataLeft.ReadOnly, createNewId);
     }
 }

 public static Associativity GetAssociativity(OperatorType operatorType) {
     switch (operatorType) {
         case OperatorType.Exponent:
         case OperatorType.LeftAssign:
         case OperatorType.Equals:
             return Associativity.Right;
     }
     return Associativity.Left;
 }

 public Operator(OperatorType type, string representation, bool unary, bool scalar, bool vector, bool matrix)
     : this(type)
 {
     this.StringRepresentation = representation;
     this.IsUnary = unary;
     this.IsScalarOperator = scalar;
     this.IsVectorOperator = vector;
     this.IsMatrixOperator = matrix;
 }