Set the set of subexpressions

@param LuceneExpression[] $expressions   The array of expressions
@return $this
425236
public function setExpressions(array $expressions)
    {
        $this->expressions = array();

        foreach ($expressions as $expression) {
            $this->addExpression($expression);
        }

        return $this;
    }
592493
public function select($expression = '*')
    {
        if (!is_array($expression)) {
            $expression = explode(',', $expression);
        }

        $this->type        = self::TYPE_SELECT;
        $this->expressions = array_merge($this->expressions, array_map(function ($expression, $alias) {
            return is_string($alias) ? "$expression AS $alias" : $expression;
        }, $expression, array_keys($expression)));

        return $this;
    }
1316590
public function norX(array $expressions)
    {
        $self = $this;
        return function ($object) use ($self, $expressions) {
            $orX = $self->orX($expressions);
            return !$orX($object);
        };
    }
102308
protected function allExpressions(array $expressions=null, &$all=null)
    {

        $expressions = $expressions ?: $this->expressions();
        $all = $all ?: [];

        foreach ($expressions as $expression) {

            $all[] = $expression;

            if ($expression instanceof HasExpressions) {
                $this->allExpressions($expression->expressions(), $all);
            }

        }

        return $all;
    }
304624
public function set( $column, $expression )
    {
        $column = $this->getIdentifier( $column );
        $expression = $this->getIdentifier( $expression );
        $this->values[$column] = $expression;
        return $this;
    }
1239418
protected function createConjunctionExpression(array $expressions, $conjunction)
    {
        // create the appropriate expression
        if (ListBuilderInterface::CONJUNCTION_AND === strtoupper($conjunction)) {
            return $this->listBuilder->createAndExpression($expressions);
        }

        return $this->listBuilder->createOrExpression($expressions);
    }
1335438
protected function addJoinExpression($expression, string $separator = 'AND')
    {
        if ($expression instanceof Closure) {
            $expression = Expression::fromClosure($expression);
        }

        $this->conditions[] = [
            'type' => 'joinExpression',
            'expression' => $expression,
            'separator' => $separator,
        ];

        return $this;
    }
1094087
public function setFilters($filters = [])
    {
        foreach ($filters as $field => $rules) {
            if ($field === 'fullSearch') {
                $this->addFilter($field, $rules, null);
                continue;
            }

            if (is_a($rules, MultiFullTextFilter::class)) {
                $this->addFilter($field, $rules, null);
                continue;
            }

            foreach ($rules as $operator => $value) {
                if (!in_array($operator, $this->availableFilters) || (empty($value) && $value != '0')) {
                    continue;
                }
                $this->addFilter($field, $value, $operator);
            }
        }

        return $this;
    }
1264063
public function andX(array $expressions)
    {
        $expr = $this->createExpr();
        foreach ($expressions as $expression) {
            $expr->addAnd($expression);
        }

        return $expr;
    }
389398
final public function value(string $expression): Collection\StringCollection
    {
        $items = $this->query($expression);
        $result = [];
        foreach ($items as $node) {
            $result[] = $node->nodeValue;
        }
        return new StringCollection($result);
    }
817482
public function withExpression(string $expression): self
    {
        if (!(new \ReflectionClass($expression))->implementsInterface(Expression::class)) {
            throw new DomainException($expression);
        }

        $self = clone $this;
        $self->expression = new $expression($self->name);

        return $self;
    }
129893
public function addAnd($expression)
    {
        $this->query['$and'][] = $expression instanceof Expr ? $expression->getQuery() : $expression;
        return $this;
    }
1142496
public function compileExpressions(QueryBuilder $queryBuilder, array $expressions) : array
    {
        $compiled = [];

        foreach ($expressions as $expr) {
            $compiled[] = $this->compileExpression($queryBuilder, $expr);
        }

        return $compiled;
    }
1318851
public function addExpression($expression)
    {
        if (!$this->expressions->contains($expression)) {
            $this->expressions[] = $expression;
        }

        return $this;
    }
1230977
public function setExpression($expression)
    {
        $definitions = array(
            '@yearly' => '0 0 1 1 *',
            '@annually' => '0 0 1 1 *',
            '@monthly' => '0 0 1 * *',
            '@weekly' => '0 0 * * 0',
            '@daily' => '0 0 * * *',
            '@hourly' => '0 * * * *'
        );

        if (isset($definitions[$expression])) {
            $expression = $definitions[$expression];
        }

        $expressionParts = explode(' ', $expression);

        if (count($expressionParts) < 5 || count($expressionParts) > 6) {
            throw new \InvalidArgumentException(sprintf('%s is not a valid CRON expression.', $expression));
        }

        $this->expression = $expression;
        $this->fields = array();

        foreach ($expressionParts as $position => $value) {
            $this->fields[$position] = $this->getField($position, $value);
        }
    }
146434
public void setCronExpression (@Nonnull final String expression) throws ParseException
  {
    final CronExpression newExp = new CronExpression (expression);

    setCronExpression (newExp);
  }
529575
public function eq($expression1, $expression2) : self
    {
        $this->expr->eq($expression1, $expression2);

        return $this;
    }