IPv4Interval::equal() - Code Metrics - Inspection of "rename method BaseType::getIntervalClass()" - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8b40f4...1a4202 )

by Peter

created 2016-12-12 14:53 UTC

IPv4Interval::equal() A

↳ Parent: IPv4Interval

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	4
Ratio	100 %

Importance

Changes

Metric	Value
dl	4
loc	4
c	0
b	0
f	0
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <[email protected]>
 * @copyright Copyright (c) 2016, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Component\Interval\IPv4;

use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
use GpsLab\Component\Interval\IntervalComparator;
use GpsLab\Component\Interval\ComparableIntervalInterface;
use GpsLab\Component\Interval\IntervalPointInterface;
use GpsLab\Component\Interval\IntervalType;

class IPv4Interval implements ComparableIntervalInterface

{
    /**
     * @var string
     */
    const REGEXP = '/^
        (?:\(|\[)                                    # start type char
        \s*
        (?<start>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3}) # start point
        \s*,\s*                                      # separator
        (?<end>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3})   # end point
        \s*
        (?:\)|\])                                    # end type char
    $/x';

    /**
     * @var IntervalType
     */
    private $type;

    /**
     * @var IntervalComparator
     */
    private $comparator;

    /**
     * @var IPv4IntervalPoint
     */
    private $start;

    /**
     * @var IPv4IntervalPoint
     */
    private $end;

    /**
     * @param IPv4IntervalPoint $start
     * @param IPv4IntervalPoint $end
     * @param IntervalType $type
     */
    private function __construct(IPv4IntervalPoint $start, IPv4IntervalPoint $end, IntervalType $type)
    {
        if ($start->gte($end)) {
            throw IncorrectIntervalException::create();
        }

        $this->type = $type;
        $this->start = $start;
        $this->end = $end;
        $this->comparator = new IntervalComparator($this);
    }

    /**
     * @param string $start
     * @param string $end
     * @param IntervalType $type
     *
     * @return self
     */
    public static function create($start, $end, IntervalType $type)
    {
        return new self(new IPv4IntervalPoint($start), new IPv4IntervalPoint($end), $type);
    }

    /**
     * @param string $start
     * @param string $end
     *
     * @return self
     */
    public static function closed($start, $end)
    {
        return static::create($start, $end, IntervalType::closed());
    }

    /**
     * @param string $start
     * @param string $end
     *
     * @return self
     */
    public static function halfClosed($start, $end)
    {
        return static::create($start, $end, IntervalType::halfClosed());
    }

    /**
     * @param string $start
     * @param string $end
     *
     * @return self
     */
    public static function halfOpen($start, $end)
    {
        return static::create($start, $end, IntervalType::halfOpen());
    }

    /**
     * @param string $start
     * @param string $end
     *
     * @return self
     */
    public static function open($start, $end)
    {
        return static::create($start, $end, IntervalType::open());
    }

    /**
     * Create interval from string.
     *
     * Example formats for all interval types:
     *   [10.0.1.0, 10.0.1.255]
     *   (10.0.0.0, 10.255.255.255]
     *   [172.16.0.0, 172.31.255.255)
     *   (192.168.0.0, 192.168.255.255)
     *
     * Spaces are ignored in format.
     *
     * @param string $string
     *
     * @return self
     */
    public static function fromString($string)
    {
        if (!preg_match(self::REGEXP, $string, $match)) {
            throw InvalidIntervalFormatException::create('[0.0.0.0, 255.255.255.255]', $string);
        }

        return self::create($match['start'], $match['end'], IntervalType::fromString($string));
    }

    /**
     * @param IPv4Interval $interval
     *
     * @return bool
     */
    public function equal(IPv4Interval $interval)
    {
        return $this->comparator->equal($interval);
    }

    /**
     * @param string $point
     *
     * @return bool
     */
    public function contains($point)
    {
        return $this->comparator->contains(new IPv4IntervalPoint($point));
    }

    /**
     * @param IPv4Interval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersects(IPv4Interval $interval, $check_interval_type = true)
    {
        return $this->comparator->intersects($interval, $check_interval_type);
    }

    /**
     * @param IPv4Interval $interval
     *
     * @return IPv4Interval|null
     */
    public function intersection(IPv4Interval $interval)
    {
        return $this->comparator->intersection($interval);
    }

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

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

    /**
     * @return IntervalType
     */
    public function type()
    {
        return $this->type;
    }

    /**
     * @return string
     */
    public function start()
    {
        return (string) $this->start;
    }

    /**
     * @return string
     */
    public function end()
    {
        return (string) $this->end;
    }

    /**
     * @return IPv4IntervalPoint
     */
    public function startPoint()
    {
        return $this->start;
    }

    /**
     * @return IPv4IntervalPoint
     */
    public function endPoint()
    {
        return $this->end;
    }

    /**
     * Returns a copy of this Interval with the start point altered.
     *
     * @param IntervalPointInterface|IPv4IntervalPoint $start
     *
     * @return self
     */
    public function withStart(IntervalPointInterface $start)
    {
        return new self($start, $this->end, $this->type);

    }

    /**
     * Returns a copy of this Interval with the end point altered.
     *
     * @param IntervalPointInterface|IPv4IntervalPoint $end
     *
     * @return self
     */
    public function withEnd(IntervalPointInterface $end)
    {
        return new self($this->start, $end, $this->type);

    }

    /**
     * Returns a copy of this Interval with the interval type altered.
     *
     * @param IntervalType $type
     *
     * @return self
     */
    public function withType(IntervalType $type)
    {
        return new self($this->start, $this->end, $type);
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->type->getReadable($this);
    }
}


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\IPv4;
12
13		use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
14		use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
15		use GpsLab\Component\Interval\IntervalComparator;
16		use GpsLab\Component\Interval\ComparableIntervalInterface;
17		use GpsLab\Component\Interval\IntervalPointInterface;
18		use GpsLab\Component\Interval\IntervalType;
19
20	View Code Duplication	class IPv4Interval implements ComparableIntervalInterface
		0 ignored issues – show Duplication introduced 2016-12-09 14:50 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
21		{
22		/**
23		* @var string
24		*/
25		const REGEXP = '/^
26		(?:\(\|\[) # start type char
27		\s*
28		(?<start>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3}) # start point
29		\s,\s # separator
30		(?<end>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3}) # end point
31		\s*
32		(?:\)\|\]) # end type char
33		$/x';
34
35		/**
36		* @var IntervalType
37		*/
38		private $type;
39
40		/**
41		* @var IntervalComparator
42		*/
43		private $comparator;
44
45		/**
46		* @var IPv4IntervalPoint
47		*/
48		private $start;
49
50		/**
51		* @var IPv4IntervalPoint
52		*/
53		private $end;
54
55		/**
56		* @param IPv4IntervalPoint $start
57		* @param IPv4IntervalPoint $end
58		* @param IntervalType $type
59		*/
60		private function __construct(IPv4IntervalPoint $start, IPv4IntervalPoint $end, IntervalType $type)
61		{
62		if ($start->gte($end)) {
63		throw IncorrectIntervalException::create();
64		}
65
66		$this->type = $type;
67		$this->start = $start;
68		$this->end = $end;
69		$this->comparator = new IntervalComparator($this);
70		}
71
72		/**
73		* @param string $start
74		* @param string $end
75		* @param IntervalType $type
76		*
77		* @return self
78		*/
79		public static function create($start, $end, IntervalType $type)
80		{
81		return new self(new IPv4IntervalPoint($start), new IPv4IntervalPoint($end), $type);
82		}
83
84		/**
85		* @param string $start
86		* @param string $end
87		*
88		* @return self
89		*/
90		public static function closed($start, $end)
91		{
92		return static::create($start, $end, IntervalType::closed());
93		}
94
95		/**
96		* @param string $start
97		* @param string $end
98		*
99		* @return self
100		*/
101		public static function halfClosed($start, $end)
102		{
103		return static::create($start, $end, IntervalType::halfClosed());
104		}
105
106		/**
107		* @param string $start
108		* @param string $end
109		*
110		* @return self
111		*/
112		public static function halfOpen($start, $end)
113		{
114		return static::create($start, $end, IntervalType::halfOpen());
115		}
116
117		/**
118		* @param string $start
119		* @param string $end
120		*
121		* @return self
122		*/
123		public static function open($start, $end)
124		{
125		return static::create($start, $end, IntervalType::open());
126		}
127
128		/**
129		* Create interval from string.
130		*
131		* Example formats for all interval types:
132		* [10.0.1.0, 10.0.1.255]
133		* (10.0.0.0, 10.255.255.255]
134		* [172.16.0.0, 172.31.255.255)
135		* (192.168.0.0, 192.168.255.255)
136		*
137		* Spaces are ignored in format.
138		*
139		* @param string $string
140		*
141		* @return self
142		*/
143		public static function fromString($string)
144		{
145		if (!preg_match(self::REGEXP, $string, $match)) {
146		throw InvalidIntervalFormatException::create('[0.0.0.0, 255.255.255.255]', $string);
147		}
148
149		return self::create($match['start'], $match['end'], IntervalType::fromString($string));
150		}
151
152		/**
153		* @param IPv4Interval $interval
154		*
155		* @return bool
156		*/
157		public function equal(IPv4Interval $interval)
158		{
159		return $this->comparator->equal($interval);
160		}
161
162		/**
163		* @param string $point
164		*
165		* @return bool
166		*/
167		public function contains($point)
168		{
169		return $this->comparator->contains(new IPv4IntervalPoint($point));
170		}
171
172		/**
173		* @param IPv4Interval $interval
174		* @param bool $check_interval_type
175		*
176		* @return bool
177		*/
178		public function intersects(IPv4Interval $interval, $check_interval_type = true)
179		{
180		return $this->comparator->intersects($interval, $check_interval_type);
181		}
182
183		/**
184		* @param IPv4Interval $interval
185		*
186		* @return IPv4Interval\|null
187		*/
188		public function intersection(IPv4Interval $interval)
189		{
190		return $this->comparator->intersection($interval);
191		}
192
193		/**
194		* The point is before the interval.
195		*
196		* @param string $point
197		*
198		* @return bool
199		*/
200		public function before($point)
201		{
202		return $this->comparator->before(new IPv4IntervalPoint($point));
203		}
204
205		/**
206		* The point is after the interval.
207		*
208		* @param string $point
209		*
210		* @return bool
211		*/
212		public function after($point)
213		{
214		return $this->comparator->after(new IPv4IntervalPoint($point));
215		}
216
217		/**
218		* @return IntervalType
219		*/
220		public function type()
221		{
222		return $this->type;
223		}
224
225		/**
226		* @return string
227		*/
228		public function start()
229		{
230		return (string) $this->start;
231		}
232
233		/**
234		* @return string
235		*/
236		public function end()
237		{
238		return (string) $this->end;
239		}
240
241		/**
242		* @return IPv4IntervalPoint
243		*/
244		public function startPoint()
245		{
246		return $this->start;
247		}
248
249		/**
250		* @return IPv4IntervalPoint
251		*/
252		public function endPoint()
253		{
254		return $this->end;
255		}
256
257		/**
258		* Returns a copy of this Interval with the start point altered.
259		*
260		* @param IntervalPointInterface\|IPv4IntervalPoint $start
261		*
262		* @return self
263		*/
264		public function withStart(IntervalPointInterface $start)
265		{
266		return new self($start, $this->end, $this->type);
		0 ignored issues – show Compatibility introduced 2016-12-12 11:21 UTC by Report Bug Copy Issue Report `$start` of type `object<GpsLab\Component\...IntervalPointInterface>` is not a sub-type of `object<GpsLab\Component\...IPv4\IPv4IntervalPoint>`. It seems like you assume a concrete implementation of the interface `GpsLab\Component\Interval\IntervalPointInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
267		}
268
269		/**
270		* Returns a copy of this Interval with the end point altered.
271		*
272		* @param IntervalPointInterface\|IPv4IntervalPoint $end
273		*
274		* @return self
275		*/
276		public function withEnd(IntervalPointInterface $end)
277		{
278		return new self($this->start, $end, $this->type);
		0 ignored issues – show Compatibility introduced 2016-12-12 11:21 UTC by Report Bug Copy Issue Report `$end` of type `object<GpsLab\Component\...IntervalPointInterface>` is not a sub-type of `object<GpsLab\Component\...IPv4\IPv4IntervalPoint>`. It seems like you assume a concrete implementation of the interface `GpsLab\Component\Interval\IntervalPointInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
279		}
280
281		/**
282		* Returns a copy of this Interval with the interval type altered.
283		*
284		* @param IntervalType $type
285		*
286		* @return self
287		*/
288		public function withType(IntervalType $type)
289		{
290		return new self($this->start, $this->end, $type);
291		}
292
293		/**
294		* @return string
295		*/
296		public function __toString()
297		{
298		return $this->type->getReadable($this);
299		}
300		}
301

gpslab / interval

Push — master ( 8b40f4...1a4202 )

IPv4Interval::equal() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like