@param int        $operator
@param Expression $operand

@return self
480257
public function update($operator, Expression $operand)
    {
        if ($this->operator === $operator && $this->operand === $operand) {
            return $this;
        }

        return new self($operator, $operand);
    }
1029608
public function setOperator(\Sulu\Bundle\ResourceBundle\Entity\Operator $operator)
    {
        $this->operator = $operator;

        return $this;
    }
1176490
protected function getOperator(string $operator): callable
    {
        if (!$this->hasOperator($operator)) {
            throw new OperatorNotFoundException($operator, sprintf('Operator "%s" does not exist.', $operator));
        }

        return $this->operators[$operator];
    }
275194
protected function CreateOperation(MathOperator $operator, Selectable $operand1, Selectable $operand2, $alias)
    {
        return new MathOperation($this->connection, $operator, $operand1, $operand2, $alias);
    }
996181
public Operator createOperator(int op, Selector operand)
  {
	Operator operator = new OperatorImpl(op, operand);

	return operator; 
  }
1118279
public function setOperator($operator)
    {
        if ($this->allowedOperators && !in_array($operator, $this->allowedOperators)) {
            throw new UnsupportedParameterException('This constraint only accepts operators: ' . implode(',', $this->allowedOperators));
        }

        $this->operator = $operator;
        return $this;
    }
786082
public function orWhereInfix($field, $operator = '=', $condition = false)
    {
        $numArgs = func_num_args();
        if ($numArgs > 2) {
            $this->where->addOrCondition($field, $condition, $operator);
        } elseif ($numArgs == 2) {
            $this->where->addOrCondition($field, $operator, '=');
        } else {
            $this->where->addOrCondition($field);
        }

        return $this;
    }
108805
public function process()
    {
        $operands = $this->getOperands();
        $allFalse = true;

        foreach ($operands as $op) {
            if ($op instanceof Container) {
                $msg = "The Or Expression only accept operands with single cardinality.";
                throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_CARDINALITY);
            } elseif ($op === null) {
                continue;
            } else {
                if (!$op instanceof QtiBoolean) {
                    $msg = "The Or Expression only accept operands with boolean baseType.";
                    throw new OperatorProcessingException($msg, $this, OperatorProcessingException::WRONG_BASETYPE);
                } else {
                    if ($op->getValue() !== false) {
                        $allFalse = false;
                    }
                }
            }
        }

        if ($allFalse === true && $operands->containsNull() === true) {
            return null;
        }

        foreach ($operands as $operand) {
            if ($operand !== null && $operand->getValue() === true) {
                return new QtiBoolean(true);
            }
        }

        return new QtiBoolean(false);
    }
825324
public function orWhere($field, $condition = false, $operator = '=')
    {
        if (func_num_args() >= 2) {
            $this->where->addOrCondition($field, $condition, $operator);
        } else {
            $this->where->addOrCondition($field);
        }

        return $this;
    }
645286
protected function processTokenLogicalOperator($operator)
    {
        if (null === $this->scope->getNode()) {
            $this->addError('Logical operator must be preceded by a valid operation.', self::ERROR_CODE_LOGICAL_OPERATOR_PRECEDED);
        } else {
            if (self::LOGICAL_OR === $operator) {
                if (null !== $this->scope->getLastOrNode()) {
                    /*
                     * If a `or` node was already registered, we create a new
                     * boolean node to join the two nodes.
                     */
                    $node = new BooleanNode($this->scope->getLastOrNode(), $this->scope->getNode(), $operator);
                    $this->scope->setNode($node);
                }

                $this->scope->setLastOrNode($this->scope->getNode());
            } else {
                $this->scope
                    ->setCurrentLeftNode($this->scope->getNode())
                    ->deleteNode();
            }

            $this->scope
                ->setCurrentOperator($operator)
                ->shiftExpression();
        }
    }
608737
private function assertOperand($operand)
    {
        if (!is_numeric($operand)) {
            throw new \InvalidArgumentException(sprintf(
                'Operand should be a numeric value, "%s" given.',
                is_object($operand) ? get_class($operand) : gettype($operand)
            ));
        }
    }
1121675
protected function equality($comparison, $operand)
    {
        return $this->expr->addCondition(new Operator\Equality(
            $this,
            $comparison,
            $this->expr->value($operand)
        ));
    }
241801
public function setOperator($pOperator = self::AUTOFILTER_COLUMN_RULE_EQUAL) {
		if (empty($pOperator))
			$pOperator = self::AUTOFILTER_COLUMN_RULE_EQUAL;
		if ((!in_array($pOperator,self::$_operators)) &&
			(!in_array($pOperator,self::$_topTenValue))) {
			throw new PHPExcel_Exception('Invalid operator for column AutoFilter Rule.');
		}
		$this->_operator = $pOperator;

		return $this;
	}
384160
protected function sanitize($operand)
    {
        if (is_int($operand)) return new IntegerNode($operand);
        if (is_float($operand)) return new NumberNode($operand);

        return $operand;
    }
248551
public Formula and(final Formula... operands) {
    final LinkedHashSet<Formula> ops = new LinkedHashSet<>(operands.length);
    Collections.addAll(ops, operands);
    return this.constructAnd(ops);
  }
120789
protected function bit(string $operator, int $value) : self
    {
        $this->requiresCurrentField();
        $this->newObj['$bit'][$this->currentField][$operator] = $value;
        return $this;
    }
603746
public function logicalOperator($operator = null)
    {
        if (is_null($operator)) {
            return $this->logicalOperator;
        }

        Helpers::ensureValidLogicalOperator($operator);

        $this->logicalOperator = $operator;

        return $this;
    }