IntervalComparator::after() - Code Metrics - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

IntervalComparator::after() A
last analyzed 2020-04-15 10:17 UTC

↳ Parent: IntervalComparator
Complexity

Conditions	2
Paths	2
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes
Metric	Value
dl	0
loc	8
ccs	0
cts	4
cp	0
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	6
<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <[email protected]>
 * @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;
    }

    /**
     * Checks if this Interval is equal to the specified interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function equal(ComparableIntervalInterface $interval)
    {
        return
            $this->interval->startPoint()->eq($interval->startPoint()) &&
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->eq($interval->endPoint()) &&
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->type()->equal($interval->type())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ;
    }

    /**
     * Does this interval contain the specified point.
     *
     * @param IntervalPointInterface $point
     *
     * @return bool
     */
    public function contains(IntervalPointInterface $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->endExcluded();
        }

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

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Does this interval intersect the specified interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function intersects(ComparableIntervalInterface $interval)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->lt($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ) {
            return false;
        }

        if ($this->interval->startPoint()->eq($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
        }

        if ($this->interval->endPoint()->eq($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
        }

        return true;
    }

    /**
     * Gets the intersection between this interval and another interval.
     *
     * @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()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->lte($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b]
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $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())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $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));
    }

    /**
     * Gets the covered interval between this Interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface
     */
    public function cover(ComparableIntervalInterface $interval)
    {
        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return $this->interval
            ->withStart($start)
            ->withEnd($end)
            ->withType(IntervalType::create($type));
    }

    /**
     * Gets the gap between this interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function gap(ComparableIntervalInterface $interval)
    {
        if ($this->interval->startPoint()->gt($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $type = IntervalType::TYPE_CLOSED;

            if (!$interval->type()->endExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }

            if (!$this->interval->type()->startExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }

            return $this->interval
                ->withStart($interval->endPoint())
                ->withEnd($this->interval->startPoint())
                ->withType(IntervalType::create($type));
        }

        if ($interval->startPoint()->gt($this->interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $type = IntervalType::TYPE_CLOSED;

            if (!$this->interval->type()->endExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }

            if (!$interval->type()->startExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }

            return $this->interval
                ->withStart($this->interval->endPoint())
                ->withEnd($interval->startPoint())
                ->withType(IntervalType::create($type));
        }

        return null; // no gap
    }

    /**
     * Does this interval abuts with the interval specified.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function abuts(ComparableIntervalInterface $interval)
    {
        return
            $interval->endPoint()->eq($this->interval->startPoint()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->eq($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ;
    }

    /**
     * Joins the interval between the adjacent.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function join(ComparableIntervalInterface $interval)
    {
        if (!$this->abuts($interval)) {
            return null;
        }

        return $this->cover($interval);
    }

    /**
     * Gets the union between this interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function union(ComparableIntervalInterface $interval)
    {
        if (!$this->intersects($interval)) {
            return null;
        }

        return $this->cover($interval);
    }

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

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return $this->interval->type()->startExcluded();
        }

        return $this->interval->startPoint()->gt($point);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

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

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return $this->interval->type()->endExcluded();
        }

        return $this->interval->endPoint()->lt($point);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
}

1		<?php
2
3		/**
4		* GpsLab component.
5		*
6		* @author Peter Gribanov <[email protected]>
7		* @copyright Copyright (c) 2016, Peter Gribanov
8		* @license http://opensource.org/licenses/MIT
9		*/
10
11		namespace GpsLab\Component\Interval;
12
13		/**
14		* The comparator must be used only in intervals for safe use the data types.
15		*/
16		class IntervalComparator
17		{
18		/**
19		* @var ComparableIntervalInterface
20		*/
21		private $interval;
22
23		/**
24		* @param ComparableIntervalInterface $interval
25		*/
26	63	public function __construct(ComparableIntervalInterface $interval)
27		{
28	63	$this->interval = $interval;
29	63	}
30
31		/**
32		* Checks if this Interval is equal to the specified interval.
33		*
34		* @param ComparableIntervalInterface $interval
35		*
36		* @return bool
37		*/
38		public function equal(ComparableIntervalInterface $interval)
39		{
40		return
gpslab / interval

IntervalComparator::after() A last analyzed 2020-04-15 10:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

IntervalComparator::after() A
last analyzed 2020-04-15 10:17 UTC
