Code Duplication - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 131-131 lines in 8 locations

src/Date/DateIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class DateIntervalComparator
{
    /**
     * @var DateInterval
     */
    private $interval;

    /**
     * @param DateInterval $interval
     */
    public function __construct(DateInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param DateIntervalPoint $point
     *
     * @return bool
     */
    public function contains(DateIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param DateInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(DateInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param DateInterval $interval
     *
     * @return DateInterval|null
     */
    public function intersectInterval(DateInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return DateInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param DateIntervalPoint $point
     *
     * @return bool
     */
    public function before(DateIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param DateIntervalPoint $point
     *
     * @return bool
     */
    public function after(DateIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/DateTime/DateTimeIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class DateTimeIntervalComparator
{
    /**
     * @var DateTimeInterval
     */
    private $interval;

    /**
     * @param DateTimeInterval $interval
     */
    public function __construct(DateTimeInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param DateTimeIntervalPoint $point
     *
     * @return bool
     */
    public function contains(DateTimeIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param DateTimeInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(DateTimeInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param DateTimeInterval $interval
     *
     * @return DateTimeInterval|null
     */
    public function intersectInterval(DateTimeInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return DateTimeInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param DateTimeIntervalPoint $point
     *
     * @return bool
     */
    public function before(DateTimeIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param DateTimeIntervalPoint $point
     *
     * @return bool
     */
    public function after(DateTimeIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/IPv4/IPv4IntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class IPv4IntervalComparator
{
    /**
     * @var IPv4Interval
     */
    private $interval;

    /**
     * @param IPv4Interval $interval
     */
    public function __construct(IPv4Interval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param IPv4IntervalPoint $point
     *
     * @return bool
     */
    public function contains(IPv4IntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param IPv4Interval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(IPv4Interval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param IPv4Interval $interval
     *
     * @return IPv4Interval|null
     */
    public function intersectInterval(IPv4Interval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return IPv4Interval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param IPv4IntervalPoint $point
     *
     * @return bool
     */
    public function before(IPv4IntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param IPv4IntervalPoint $point
     *
     * @return bool
     */
    public function after(IPv4IntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/Month/MonthIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class MonthIntervalComparator
{
    /**
     * @var MonthInterval
     */
    private $interval;

    /**
     * @param MonthInterval $interval
     */
    public function __construct(MonthInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param MonthIntervalPoint $point
     *
     * @return bool
     */
    public function contains(MonthIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param MonthInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(MonthInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param MonthInterval $interval
     *
     * @return MonthInterval|null
     */
    public function intersectInterval(MonthInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return MonthInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param MonthIntervalPoint $point
     *
     * @return bool
     */
    public function before(MonthIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param MonthIntervalPoint $point
     *
     * @return bool
     */
    public function after(MonthIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/Number/NumberIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class NumberIntervalComparator
{
    /**
     * @var NumberInterval
     */
    private $interval;

    /**
     * @param NumberInterval $interval
     */
    public function __construct(NumberInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param NumberIntervalPoint $point
     *
     * @return bool
     */
    public function contains(NumberIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param NumberInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(NumberInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param NumberInterval $interval
     *
     * @return NumberInterval|null
     */
    public function intersectInterval(NumberInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return NumberInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param NumberIntervalPoint $point
     *
     * @return bool
     */
    public function before(NumberIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param NumberIntervalPoint $point
     *
     * @return bool
     */
    public function after(NumberIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/Time/TimeIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class TimeIntervalComparator
{
    /**
     * @var TimeInterval
     */
    private $interval;

    /**
     * @param TimeInterval $interval
     */
    public function __construct(TimeInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param TimeIntervalPoint $point
     *
     * @return bool
     */
    public function contains(TimeIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param TimeInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(TimeInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param TimeInterval $interval
     *
     * @return TimeInterval|null
     */
    public function intersectInterval(TimeInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return TimeInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param TimeIntervalPoint $point
     *
     * @return bool
     */
    public function before(TimeIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param TimeIntervalPoint $point
     *
     * @return bool
     */
    public function after(TimeIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/Week/WeekIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class WeekIntervalComparator
{
    /**
     * @var WeekInterval
     */
    private $interval;

    /**
     * @param WeekInterval $interval
     */
    public function __construct(WeekInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param WeekIntervalPoint $point
     *
     * @return bool
     */
    public function contains(WeekIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param WeekInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(WeekInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param WeekInterval $interval
     *
     * @return WeekInterval|null
     */
    public function intersectInterval(WeekInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return WeekInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param WeekIntervalPoint $point
     *
     * @return bool
     */
    public function before(WeekIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param WeekIntervalPoint $point
     *
     * @return bool
     */
    public function after(WeekIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


src/Year/YearIntervalComparator.php 1 location



use GpsLab\Component\Interval\IntervalType;

class YearIntervalComparator
{
    /**
     * @var YearInterval
     */
    private $interval;

    /**
     * @param YearInterval $interval
     */
    public function __construct(YearInterval $interval)
    {
        $this->interval = $interval;
    }

    /**
     * @param YearIntervalPoint $point
     *
     * @return bool
     */
    public function contains(YearIntervalPoint $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
    }

    /**
     * @param YearInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersect(YearInterval $interval, $check_interval_type = true)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
            $this->interval->endPoint()->lt($interval->startPoint())
        ) {
            return false;
        }

        if ($check_interval_type) {
            if ($this->interval->startPoint()->eq($interval->endPoint())) {
                return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
            }

            if ($this->interval->endPoint()->eq($interval->startPoint())) {
                return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
            }
        }

        return true;
    }

    /**
     * @param YearInterval $interval
     *
     * @return YearInterval|null
     */
    public function intersectInterval(YearInterval $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
            $this->interval->endPoint()->lte($interval->startPoint())
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b] = (b-1, b+1)
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return YearInterval::create($start->value(), $end->value(), IntervalType::create($type));
    }

    /**
     * The point is before the interval
     *
     * @param YearIntervalPoint $point
     *
     * @return bool
     */
    public function before(YearIntervalPoint $point)
    {
        return $this->interval->startPoint()->gt($point);
    }

    /**
     * The point is after the interval
     *
     * @param YearIntervalPoint $point
     *
     * @return bool
     */
    public function after(YearIntervalPoint $point)
    {
        return $this->interval->endPoint()->lt($point);
    }
}


		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class DateIntervalComparator
15		{
16		/**
17		* @var DateInterval
18		*/
19		private $interval;
20
21		/**
22		* @param DateInterval $interval
23		*/
24		public function __construct(DateInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param DateIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(DateIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param DateInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(DateInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param DateInterval $interval
77		*
78		* @return DateInterval\|null
79		*/
80		public function intersectInterval(DateInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return DateInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param DateIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(DateIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param DateIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(DateIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class DateTimeIntervalComparator
15		{
16		/**
17		* @var DateTimeInterval
18		*/
19		private $interval;
20
21		/**
22		* @param DateTimeInterval $interval
23		*/
24		public function __construct(DateTimeInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param DateTimeIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(DateTimeIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param DateTimeInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(DateTimeInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param DateTimeInterval $interval
77		*
78		* @return DateTimeInterval\|null
79		*/
80		public function intersectInterval(DateTimeInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return DateTimeInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param DateTimeIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(DateTimeIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param DateTimeIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(DateTimeIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class IPv4IntervalComparator
15		{
16		/**
17		* @var IPv4Interval
18		*/
19		private $interval;
20
21		/**
22		* @param IPv4Interval $interval
23		*/
24		public function __construct(IPv4Interval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param IPv4IntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(IPv4IntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param IPv4Interval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(IPv4Interval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param IPv4Interval $interval
77		*
78		* @return IPv4Interval\|null
79		*/
80		public function intersectInterval(IPv4Interval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return IPv4Interval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param IPv4IntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(IPv4IntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param IPv4IntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(IPv4IntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class MonthIntervalComparator
15		{
16		/**
17		* @var MonthInterval
18		*/
19		private $interval;
20
21		/**
22		* @param MonthInterval $interval
23		*/
24		public function __construct(MonthInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param MonthIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(MonthIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param MonthInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(MonthInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param MonthInterval $interval
77		*
78		* @return MonthInterval\|null
79		*/
80		public function intersectInterval(MonthInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return MonthInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param MonthIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(MonthIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param MonthIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(MonthIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class NumberIntervalComparator
15		{
16		/**
17		* @var NumberInterval
18		*/
19		private $interval;
20
21		/**
22		* @param NumberInterval $interval
23		*/
24		public function __construct(NumberInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param NumberIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(NumberIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param NumberInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(NumberInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param NumberInterval $interval
77		*
78		* @return NumberInterval\|null
79		*/
80		public function intersectInterval(NumberInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return NumberInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param NumberIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(NumberIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param NumberIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(NumberIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class TimeIntervalComparator
15		{
16		/**
17		* @var TimeInterval
18		*/
19		private $interval;
20
21		/**
22		* @param TimeInterval $interval
23		*/
24		public function __construct(TimeInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param TimeIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(TimeIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param TimeInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(TimeInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param TimeInterval $interval
77		*
78		* @return TimeInterval\|null
79		*/
80		public function intersectInterval(TimeInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return TimeInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param TimeIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(TimeIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param TimeIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(TimeIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class WeekIntervalComparator
15		{
16		/**
17		* @var WeekInterval
18		*/
19		private $interval;
20
21		/**
22		* @param WeekInterval $interval
23		*/
24		public function __construct(WeekInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param WeekIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(WeekIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param WeekInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(WeekInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param WeekInterval $interval
77		*
78		* @return WeekInterval\|null
79		*/
80		public function intersectInterval(WeekInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return WeekInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param WeekIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(WeekIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param WeekIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(WeekIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

		@@ 14-144 (lines=131) @@
11
12		use GpsLab\Component\Interval\IntervalType;
13
14		class YearIntervalComparator
15		{
16		/**
17		* @var YearInterval
18		*/
19		private $interval;
20
21		/**
22		* @param YearInterval $interval
23		*/
24		public function __construct(YearInterval $interval)
25		{
26		$this->interval = $interval;
27		}
28
29		/**
30		* @param YearIntervalPoint $point
31		*
32		* @return bool
33		*/
34		public function contains(YearIntervalPoint $point)
35		{
36		if ($this->interval->startPoint()->eq($point)) {
37		return !$this->interval->type()->startExcluded();
38		}
39
40		if ($this->interval->endPoint()->eq($point)) {
41		return !$this->interval->type()->endExcluded();
42		}
43
44		return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
45		}
46
47		/**
48		* @param YearInterval $interval
49		* @param bool $check_interval_type
50		*
51		* @return bool
52		*/
53		public function intersect(YearInterval $interval, $check_interval_type = true)
54		{
55		if (
56		$this->interval->startPoint()->gt($interval->endPoint()) \|\|
57		$this->interval->endPoint()->lt($interval->startPoint())
58		) {
59		return false;
60		}
61
62		if ($check_interval_type) {
63		if ($this->interval->startPoint()->eq($interval->endPoint())) {
64		return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
65		}
66
67		if ($this->interval->endPoint()->eq($interval->startPoint())) {
68		return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
69		}
70		}
71
72		return true;
73		}
74
75		/**
76		* @param YearInterval $interval
77		*
78		* @return YearInterval\|null
79		*/
80		public function intersectInterval(YearInterval $interval)
81		{
82		// intervals is not intersect or impossible create interval from one point
83		if (
84		$this->interval->startPoint()->gte($interval->endPoint()) \|\|
85		$this->interval->endPoint()->lte($interval->startPoint())
86		) {
87		// ignore closed intervals:
88		// [a, b] \| [b, c] = [b, b] = (b-1, b+1)
89		return null;
90		}
91
92		$type = IntervalType::TYPE_CLOSED;
93
94		if ($this->interval->startPoint()->lt($interval->startPoint())) {
95		$start = $interval->startPoint();
96		if ($interval->type()->startExcluded()) {
97		$type \|= IntervalType::TYPE_START_EXCLUDED;
98		}
99		} else {
100		$start = $this->interval->startPoint();
101		if ($this->interval->type()->startExcluded()) {
102		$type \|= IntervalType::TYPE_START_EXCLUDED;
103		}
104		}
105
106		if ($this->interval->endPoint()->gt($interval->endPoint())) {
107		$end = $interval->endPoint();
108		if ($interval->type()->endExcluded()) {
109		$type \|= IntervalType::TYPE_END_EXCLUDED;
110		}
111		} else {
112		$end = $this->interval->endPoint();
113		if ($this->interval->type()->endExcluded()) {
114		$type \|= IntervalType::TYPE_END_EXCLUDED;
115		}
116		}
117
118		return YearInterval::create($start->value(), $end->value(), IntervalType::create($type));
119		}
120
121		/**
122		* The point is before the interval
123		*
124		* @param YearIntervalPoint $point
125		*
126		* @return bool
127		*/
128		public function before(YearIntervalPoint $point)
129		{
130		return $this->interval->startPoint()->gt($point);
131		}
132
133		/**
134		* The point is after the interval
135		*
136		* @param YearIntervalPoint $point
137		*
138		* @return bool
139		*/
140		public function after(YearIntervalPoint $point)
141		{
142		return $this->interval->endPoint()->lt($point);
143		}
144		}
145

gpslab / interval

Code Duplication Length = 131-131 lines in 8 locations

src/Date/DateIntervalComparator.php 1 location

src/DateTime/DateTimeIntervalComparator.php 1 location

src/IPv4/IPv4IntervalComparator.php 1 location

src/Month/MonthIntervalComparator.php 1 location

src/Number/NumberIntervalComparator.php 1 location

src/Time/TimeIntervalComparator.php 1 location

src/Week/WeekIntervalComparator.php 1 location

src/Year/YearIntervalComparator.php 1 location