hanneskod\yaysondb\Operators

Complexity

Total Complexity

22

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	doc()	0	4	1
A	not()	0	4	1
A	exists()	0	4	1
A	type()	0	4	1
A	in()	0	4	1
A	regexp()	0	4	1
A	equals()	0	4	1
A	same()	0	4	1
A	greaterThan()	0	4	1
A	greaterThanOrEquals()	0	7	1
A	lessThan()	0	4	1
A	lessThanOrEquals()	0	7	1
A	all()	0	4	1
A	atLeastOne()	0	4	1
A	exactly()	0	4	1
A	none()	0	4	1
A	one()	0	4	1
A	listAll()	0	4	1
A	listAtLeastOne()	0	4	1
A	listExactly()	0	4	1
A	listNone()	0	4	1
A	listOne()	0	4	1

<?php

declare(strict_types = 1);

namespace hanneskod\yaysondb;

use hanneskod\yaysondb\Expression\ExpressionInterface;

/**
 * Collection of query operators
 */
class Operators
{
    public static function doc(array $query)
    {
        return new Expression\Doc($query);
    }

    public static function not(ExpressionInterface $expr)
    {
        return new Expression\Not($expr);
    }

    public static function exists()
    {
        return new Expression\Exists();
    }

    public static function type($type)
    {
        return new Expression\Type($type);
    }

    public static function in(array $list)
    {
        return new Expression\In($list);
    }

    public static function regexp($regexp)
    {
        return new Expression\Regexp($regexp);
    }

    public static function equals($operand)
    {
        return new Expression\Comparator\Equals($operand);
    }

    public static function same($operand)
    {
        return new Expression\Comparator\Same($operand);
    }

    public static function greaterThan($operand)
    {
        return new Expression\Comparator\GreaterThan($operand);
    }

    public static function greaterThanOrEquals($operand)
    {
        return self::atLeastOne(
            self::equals($operand),
            self::greaterThan($operand)
        );
    }

    public static function lessThan($operand)
    {
        return self::not(self::greaterThanOrEquals($operand));
    }

    public static function lessThanOrEquals($operand)
    {
        return self::atLeastOne(
            self::equals($operand),
            self::lessThan($operand)
        );
    }

    public static function all(ExpressionInterface ...$exprs)
    {
        return new Expression\Counter\All(...$exprs);
    }

    public static function atLeastOne(ExpressionInterface ...$exprs)
    {
        return new Expression\Counter\AtLeastOne(...$exprs);
    }

    public static function exactly($count, ExpressionInterface ...$exprs)
    {
        return new Expression\Counter\Exactly($count, ...$exprs);
    }

    public static function none(ExpressionInterface ...$exprs)
    {
        return self::not(self::atLeastOne(...$exprs));
    }

    public static function one(ExpressionInterface ...$exprs)
    {
        return self::exactly(1, ...$exprs);
    }

    public static function listAll(ExpressionInterface $expr)
    {
        return new Expression\Set\ListAll($expr);
    }

    public static function listAtLeastOne(ExpressionInterface $expr)
    {
        return new Expression\Set\ListAtLeastOne($expr);
    }

    public static function listExactly($count, ExpressionInterface $expr)
    {
        return new Expression\Set\ListExactly($count, $expr);
    }

    public static function listNone(ExpressionInterface $expr)
    {
        return self::not(self::listAtLeastOne($expr));
    }

    public static function listOne(ExpressionInterface $expr)
    {
        return self::listExactly(1, $expr);
    }
}