public static Boolean Evaluate(Object state, ref Boolean error, Operator @operator, String text)
		{
			Combat.Character character = state as Combat.Character;
			if (character == null)
			{
				error = true;
				return false;
			}

			String authorname = character.BasePlayer.Profile.Author;
			if (authorname == null)
			{
				error = true;
				return false;
			}

			Boolean result = String.Equals(authorname, text, StringComparison.OrdinalIgnoreCase);

			switch (@operator)
			{
				case Operator.Equals:
					return result;

				case Operator.NotEquals:
					return !result;

				default:
					error = true;
					return false;
			}
		}

 public Binary(SourceSpan span, Operator op, Expression left, Expression right)
     : base(span)
 {
     _op = op;
     _left = left;
     _right = right;
 }

 internal UnsafeAccessExpression(CsTokenList tokens, Operator operatorType, Expression value)
     : base(ExpressionType.UnsafeAccess, tokens)
 {
     this.operatorType = operatorType;
     this.value = value;
     base.AddExpression(value);
 }

 public SimpleSelectNode(IQueryPlanNode child, ObjectName leftVar, Operator op, Expression rightExpression)
     : base(child)
 {
     this.leftVar = leftVar;
     this.op = op;
     this.rightExpression = rightExpression;
 }

        public static string GetName(Operator type)
        {
            string result = String.Empty;

            switch (type)
            {
                case Operator.Equal:
                    result = "==";
                    break;
                case Operator.GreaterThan:
                    result = ">";
                    break;
                case Operator.GreaterThanEqual:
                    result = ">=";
                    break;
                case Operator.LessThan:
                    result = "<";
                    break;
                case Operator.LessThanEqual:
                    result = "<=";
                    break;
                case Operator.NotEqual:
                    result = "!=";
                    break;
            }

            return result;
        }

 private Calculation(Column column, Guid id, double operand, Operator @operator)
 {
     _column = column;
     Id = id;
     Operand = operand;
     Operator = @operator;
 }

        /*cmpXslt:*/
        static bool cmpQueryQueryE(Operator.Op op, object val1, object val2) {
            Debug.Assert(op == Operator.Op.EQ || op == Operator.Op.NE);
            bool isEQ = (op == Operator.Op.EQ);

            NodeSet n1 = new NodeSet(val1);
            NodeSet n2 = new NodeSet(val2);

            while (true) {
                if (! n1.MoveNext()) {
                    return false;
                }
                if (! n2.MoveNext()) {
                    return false;
                }

                string str1 = n1.Value;

                do {
                    if ((str1 == n2.Value) == isEQ) {
                        return true;
                    }
                }while (n2.MoveNext());
                n2.Reset();    
            }
        }

        private static void InsertBinaryOperationMethod(Core core, CodeBlockNode root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0)
        {
            FunctionDefinitionNode funcDefNode = new FunctionDefinitionNode();
            funcDefNode.access = CompilerDefinitions.AccessModifier.kPublic;
            funcDefNode.IsAssocOperator = true;
            funcDefNode.IsBuiltIn = true;
            funcDefNode.Name = Op.GetOpFunction(op);
            funcDefNode.ReturnType = new Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank };
            ArgumentSignatureNode args = new ArgumentSignatureNode();
            args.AddArgument(new VarDeclNode()
            {
                Access = CompilerDefinitions.AccessModifier.kPublic,
                NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kLHS),
                ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank }
            });
            args.AddArgument(new VarDeclNode()
            {
                Access = CompilerDefinitions.AccessModifier.kPublic,
                NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kRHS),
                ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank }
            });
            funcDefNode.Signature = args;

            CodeBlockNode body = new CodeBlockNode();

            var lhs = AstFactory.BuildIdentifier(DSASM.Constants.kLHS);
            var rhs = AstFactory.BuildIdentifier(DSASM.Constants.kRHS);
            var binaryExpr = AstFactory.BuildBinaryExpression(lhs, rhs, op);
            body.Body.Add(AstFactory.BuildReturnStatement(binaryExpr));

            funcDefNode.FunctionBody = body;
            root.Body.Add(funcDefNode);
        }

 public void ProcessOperator(Operator op)
 {
     if (ProcessOperatorObject != null)
         ProcessOperatorObject(op);
     foreach (var obj in op.Children)
         obj.AcceptVisitor(this);
 }

        public string BuildSelectSqlFor(string tableName, string[] fields,
            string[] filterFields, Operator[] filterOperators, string[] filterValues,
            string[] orders, int limitResultSet)
        {
            string sql = "select ";
            if (limitResultSet > 0)
                sql += "top " + limitResultSet + " ";

            if (ArrayHelper.IsNull(fields))
                sql += "*";
            else
                sql += string.Join(", ", fields);

            sql += " from " + tableName + " ";
            if (!ArrayHelper.IsNull(filterFields))
            {
                sql += "where ";
                for (int i = 0; i < filterFields.Length; i++)
                {
                    if (i > 0) sql += " and ";
                    sql += filterFields[i] + " " + OperatorString(filterOperators[i], filterValues[i]);
                }
            }

            if (!ArrayHelper.IsNull(orders))
            {
                sql += " order by ";
                sql += string.Join(", ", orders);
            }

            return sql;
        }

 internal QueryExpression(string FieldName, Operator Operator, Guid Value)
 {
     this.Type = ExpressionType.String;
     this.FieldName = FieldName;
     this.Operator = Operator;
     this.Value = Value.ToString();
 }

 public Delete(string table, Operator where, bool allowMultiple)
 {
     Table.Name = table;
     AllowMultiple = allowMultiple;
     Where = where;
     Filter = FilterType.Where;
 }

        public static IMongoQuery ExpressionQuery(string name, Operator optor, BsonValue value)
        {
            switch (optor)
            {
                case Operator.EQ:
                    return M.Query.EQ(name, value);

                case Operator.GT:
                    return M.Query.GT(name, value);

                case Operator.GTE:
                    return M.Query.GTE(name, value);

                case Operator.ISNULL:
                    return M.Query.EQ(name, null);

                case Operator.LT:
                    return M.Query.LT(name, value);

                case Operator.LTE:
                    return M.Query.LTE(name, value);

                case Operator.NOTNULL:
                    return M.Query.NE(name, null);

                default:
                    throw new ArgumentException(String.Format("Invalid operator {0} on token parameter {1}", optor.ToString(), name));
            }
        }

        private void ExecuteLastOperator(Operator newOperator)
        {
            decimal currentValue = Convert.ToDecimal(textBoxDisplay.Text);
            decimal newValue = currentValue;

            if (numberHitSinceLastOperator)
            {
                switch (lastOperator)
                {
                    case Operator.Plus:
                        newValue = valueSoFar + currentValue;
                        break;
                    case Operator.Minus:
                        newValue = valueSoFar - currentValue;
                        break;
                    case Operator.Times:
                        newValue = valueSoFar * currentValue;
                        break;
                    case Operator.Divide:
                        if (currentValue == 0)
                            newValue = 0;
                        else
                            newValue = valueSoFar / currentValue;
                        break;
                    case Operator.Equals:
                        newValue = currentValue;
                        break;
                }
            }

            valueSoFar = newValue;
            lastOperator = newOperator;
            numberHitSinceLastOperator = false;
            textBoxDisplay.Text = valueSoFar.ToString();
        }

 public void Connect(Operator outOp, IOOutlet output, Operator inOp, IOOutlet input, bool serialize = true)
 {
     Connections.Add(new IOConnection() { From=outOp, Output=output, To=inOp, Input=input });
     if (serialize) {
         TemplateSerializer.Serialize(this);
     }
 }

		public static Boolean Evaluate(Object state, ref Boolean error, Operator @operator, xnaMugen.StateType statetype)
		{
			Combat.Character character = state as Combat.Character;
			if (character == null)
			{
				error = true;
				return false;
			}

			Combat.Player opponent = character.GetOpponent();
			if (opponent == null)
			{
				error = true;
				return false;
			}

			if (statetype == xnaMugen.StateType.Unchanged || statetype == xnaMugen.StateType.None)
			{
				error = true;
				return false;
			}

			switch (@operator)
			{
				case Operator.Equals:
					return statetype == opponent.StateType;

				case Operator.NotEquals:
					return statetype != opponent.StateType;

				default:
					error = true;
					return false;
			}
		}

 private static IMongoQuery CreateFilter(ModelInfo.SearchParamDefinition parameter, Operator op, String modifier, Expression operand)
 {
     if (op == Operator.CHAIN)
     {
         throw new NotSupportedException("Chain operators should be handled in MongoSearcher.");
     }
     else // There's only one operand.
     {
         var valueOperand = (ValueExpression)operand;
         switch (parameter.Type)
         {
             case Conformance.SearchParamType.Composite:
                 return CompositeQuery(parameter, op, modifier, valueOperand);
             case Conformance.SearchParamType.Date:
                 return DateQuery(parameter.Name, op, modifier, valueOperand);
             case Conformance.SearchParamType.Number:
                 return NumberQuery(parameter.Name, op, valueOperand);
             case Conformance.SearchParamType.Quantity:
                 return QuantityQuery(parameter.Name, op, modifier, valueOperand);
             case Conformance.SearchParamType.Reference:
                 //Chain is handled in MongoSearcher, so here we have the result of a closed criterium: IN [ list of id's ]
                 return StringQuery(parameter.Name, op, modifier, valueOperand);
             case Conformance.SearchParamType.String:
                 return StringQuery(parameter.Name, op, modifier, valueOperand);
             case Conformance.SearchParamType.Token:
                 return TokenQuery(parameter.Name, op, modifier, valueOperand);
             default:
                 //return M.Query.Null;
                 throw new NotSupportedException("Only SearchParamType.Number or String is supported.");
         }
     }
 }

        public override Object PerformOperation(Executer exec, Operator op, Object otherTerm)
        {
            if (op == null)
                return this;

            this.CheckOperation(op);

            string sReturn = "";
            string sThis = (string)this.GetUnboxed(exec);
            string sOther = otherTerm.GetUnboxed(exec).ToString();
            switch (op.InternalTokens)
            {
                case "+":
                    sReturn = sThis + sOther;
                    break;
                case "-":
                    sReturn = sThis.Replace(sOther, "");
                    break;
                case "*":
                    for (int i = Convert.ToInt32(sOther)-1; i>=0; i--)
                        sReturn+=sThis;
                    break;
            }

            //this.m_value = sReturn;
            //return this;
            return Types.Object.CreateType(sReturn);
        }

        // tests building and pretty-printing
        static void test1()
        {
            Template t = new Template();
            t.Add("a", ClassType.mark.PLUS);
            t.Add("b", ClassType.mark.MINUS);
            t.Add("c", ClassType.mark.HASH);

            Template t2 = new Template();
            t2.Add("a", ClassType.mark.PLUS);
            t2.Add("b", ClassType.mark.MINUS);
            t2.Add("c", ClassType.mark.MINUS);

            Scheme s = new Scheme();
            s.Add(t);
            s.Add(t2);

            Scheme s2 = new Scheme();

            Offering o = new Offering(1, 1);
            o.addInputScheme(1, s);
            o.addOutputScheme(1, s2);
            o.addFeedbackInputScheme(1, Scheme.SchemeAsAny());
            o.addFeedbackOutputScheme(1, Scheme.SchemeAsAny());

            Operator op = new Operator("SELECT", 1, 1);
            op.AddOffering(o);
            op.AddOffering(o);

            Console.WriteLine(op.ToString());
            Console.ReadLine();
        }

        public HistoryReadModelTests()
        {
            _model = new HistoryReadModel();

            _user1 = new Operator { Name = "Andy Dote" };
            _user2 = new Operator { Name = "John Wick" };
        }