GpsLab\Component\Interval\IntervalComparator

Complexity

Total Complexity

27

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	equal()	0	8	3
A	contains()	0	12	4
B	intersects()	0	21	8
D	intersection()	0	43	9
A	before()	0	4	1
A	after()	0	4	1

<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <info@peter-gribanov.ru>
 * @copyright Copyright (c) 2016, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Component\Interval;

/**
 * The comparator must be used only in intervals for safe use the data types.
 */
class IntervalComparator
{
    /**
     * @var ComparableIntervalInterface
     */
    private $interval;

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

    /**
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function equal(ComparableIntervalInterface $interval)
    {
        return (
            $this->interval->startPoint()->eq($interval->startPoint()) &&
            $this->interval->endPoint()->eq($interval->endPoint()) &&
            $this->interval->type()->equal($interval->type())
        );
    }

    /**
     * @param IntervalPointInterface $point
     *
     * @return bool
     */
    public function contains(IntervalPointInterface $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 ComparableIntervalInterface $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersects(ComparableIntervalInterface $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 ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function intersection(ComparableIntervalInterface $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]
            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 $this->interval
            ->withStart($start)
            ->withEnd($end)
            ->withType(IntervalType::create($type));
    }

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

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