IPv4Interval::withType() - Code Metrics - Inspection of "add method iterate() for iterate IPv4 interval and..." - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 59b106...2838f8 )

by Peter

created 2016-12-14 14:24 UTC

IPv4Interval::withType() A

↳ Parent: IPv4Interval

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	4
Ratio	100 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?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));
    }

    /**
     * Checks if this interval is equal to the specified interval.
     *
     * @param IPv4Interval $interval
     *
     * @return bool
     */
    public function equal(IPv4Interval $interval)
    {
        return $this->comparator->equal($interval);
    }

    /**
     * Does this interval contain the specified point.
     *
     * @param string $point
     *
     * @return bool
     */
    public function contains($point)
    {
        return $this->comparator->contains(new IPv4IntervalPoint($point));
    }

    /**
     * Does this interval intersect the specified interval.
     *
     * @param IPv4Interval $interval
     *
     * @return bool
     */
    public function intersects(IPv4Interval $interval)
    {
        return $this->comparator->intersects($interval);
    }

    /**
     * Gets the intersection between this interval and another interval.
     *
     * @param IPv4Interval $interval
     *
     * @return self|null
     */
    public function intersection(IPv4Interval $interval)
    {
        return $this->comparator->intersection($interval);
    }

    /**
     * Gets the covered interval between this Interval and another interval.
     *
     * @param IPv4Interval $interval
     *
     * @return self
     */
    public function cover(IPv4Interval $interval)
    {
        return $this->comparator->cover($interval);
    }

    /**
     * Gets the gap between this interval and another interval.
     *
     * @param IPv4Interval $interval
     *
     * @return self|null
     */
    public function gap(IPv4Interval $interval)
    {
        return $this->comparator->gap($interval);
    }

    /**
     * Does this interval abut with the interval specified.
     *
     * @param IPv4Interval $interval
     *
     * @return bool
     */
    public function abuts(IPv4Interval $interval)
    {
        return $this->comparator->abuts($interval);
    }

    /**
     * Joins the interval between the adjacent.
     *
     * @param IPv4Interval $interval
     *
     * @return self|null
     */
    public function join(IPv4Interval $interval)
    {
        return $this->comparator->join($interval);
    }

    /**
     * Gets the union between this interval and another interval.
     *
     * @param IPv4Interval $interval
     *
     * @return self|null
     */
    public function union(IPv4Interval $interval)
    {
        return $this->comparator->union($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));
    }

    /**
     * @param int $step
     *
     * @return \Generator
     */
    public function iterate($step = 1)
    {
        $end = $this->endPoint()->value();
        $ip = $this->startPoint()->value();

        while ($ip < $end) {
            yield long2ip($ip);
            $ip += $step;
        }
    }

    /**
     * @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	2		private function __construct(IPv4IntervalPoint $start, IPv4IntervalPoint $end, IntervalType $type)
61			{
62	2		if ($start->gte($end)) {
63			throw IncorrectIntervalException::create();
64			}
65
66	2		$this->type = $type;
67	2		$this->start = $start;
68	2		$this->end = $end;
69	2		$this->comparator = new IntervalComparator($this);
70	2		}
71
72			/**
73			* @param string $start
74			* @param string $end
75			* @param IntervalType $type
76			*
77			* @return self
78			*/
79	2		public static function create($start, $end, IntervalType $type)
80			{
81	2		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	2		public static function fromString($string)
144			{
145	2		if (!preg_match(self::REGEXP, $string, $match)) {
146			throw InvalidIntervalFormatException::create('[0.0.0.0, 255.255.255.255]', $string);
147			}
148
149	2		return self::create($match['start'], $match['end'], IntervalType::fromString($string));
150			}
151
152			/**
153			* Checks if this interval is equal to the specified interval.
154			*
155			* @param IPv4Interval $interval
156			*
157			* @return bool
158			*/
159			public function equal(IPv4Interval $interval)
160			{
161			return $this->comparator->equal($interval);
162			}
163
164			/**
165			* Does this interval contain the specified point.
166			*
167			* @param string $point
168			*
169			* @return bool
170			*/
171			public function contains($point)
172			{
173			return $this->comparator->contains(new IPv4IntervalPoint($point));
174			}
175
176			/**
177			* Does this interval intersect the specified interval.
178			*
179			* @param IPv4Interval $interval
180			*
181			* @return bool
182			*/
183			public function intersects(IPv4Interval $interval)
184			{
185			return $this->comparator->intersects($interval);
186			}
187
188			/**
189			* Gets the intersection between this interval and another interval.
190			*
191			* @param IPv4Interval $interval
192			*
193			* @return self\|null
194			*/
195			public function intersection(IPv4Interval $interval)
196			{
197			return $this->comparator->intersection($interval);
198			}
199
200			/**
201			* Gets the covered interval between this Interval and another interval.
202			*
203			* @param IPv4Interval $interval
204			*
205			* @return self
206			*/
207			public function cover(IPv4Interval $interval)
208			{
209			return $this->comparator->cover($interval);
210			}
211
212			/**
213			* Gets the gap between this interval and another interval.
214			*
215			* @param IPv4Interval $interval
216			*
217			* @return self\|null
218			*/
219			public function gap(IPv4Interval $interval)
220			{
221			return $this->comparator->gap($interval);
222			}
223
224			/**
225			* Does this interval abut with the interval specified.
226			*
227			* @param IPv4Interval $interval
228			*
229			* @return bool
230			*/
231			public function abuts(IPv4Interval $interval)
232			{
233			return $this->comparator->abuts($interval);
234			}
235
236			/**
237			* Joins the interval between the adjacent.
238			*
239			* @param IPv4Interval $interval
240			*
241			* @return self\|null
242			*/
243			public function join(IPv4Interval $interval)
244			{
245			return $this->comparator->join($interval);
246			}
247
248			/**
249			* Gets the union between this interval and another interval.
250			*
251			* @param IPv4Interval $interval
252			*
253			* @return self\|null
254			*/
255			public function union(IPv4Interval $interval)
256			{
257			return $this->comparator->union($interval);
258			}
259
260			/**
261			* The point is before the interval.
262			*
263			* @param string $point
264			*
265			* @return bool
266			*/
267			public function before($point)
268			{
269			return $this->comparator->before(new IPv4IntervalPoint($point));
270			}
271
272			/**
273			* The point is after the interval.
274			*
275			* @param string $point
276			*
277			* @return bool
278			*/
279			public function after($point)
280			{
281			return $this->comparator->after(new IPv4IntervalPoint($point));
282			}
283
284			/**
285			* @param int $step
286			*
287			* @return \Generator
288			*/
289			public function iterate($step = 1)
290			{
291			$end = $this->endPoint()->value();
292			$ip = $this->startPoint()->value();
293
294			while ($ip < $end) {
295			yield long2ip($ip);
296			$ip += $step;
297			}
298			}
299
300			/**
301			* @return IntervalType
302			*/
303			public function type()
304			{
305			return $this->type;
306			}
307
308			/**
309			* @return string
310			*/
311			public function start()
312			{
313			return (string) $this->start;
314			}
315
316			/**
317			* @return string
318			*/
319			public function end()
320			{
321			return (string) $this->end;
322			}
323
324			/**
325			* @return IPv4IntervalPoint
326			*/
327	1		public function startPoint()
328			{
329	1		return $this->start;
330			}
331
332			/**
333			* @return IPv4IntervalPoint
334			*/
335	1		public function endPoint()
336			{
337	1		return $this->end;
338			}
339
340			/**
341			* Returns a copy of this Interval with the start point altered.
342			*
343			* @param IntervalPointInterface\|IPv4IntervalPoint $start
344			*
345			* @return self
346			*/
347			public function withStart(IntervalPointInterface $start)
348			{
349			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...
350			}
351
352			/**
353			* Returns a copy of this Interval with the end point altered.
354			*
355			* @param IntervalPointInterface\|IPv4IntervalPoint $end
356			*
357			* @return self
358			*/
359			public function withEnd(IntervalPointInterface $end)
360			{
361			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...
362			}
363
364			/**
365			* Returns a copy of this Interval with the interval type altered.
366			*
367			* @param IntervalType $type
368			*
369			* @return self
370			*/
371			public function withType(IntervalType $type)
372			{
373			return new self($this->start, $this->end, $type);
374			}
375
376			/**
377			* @return string
378			*/
379	1		public function __toString()
380			{
381	1		return $this->type->getReadable($this);
382			}
383			}
384

gpslab / interval

Push — master ( 59b106...2838f8 )

IPv4Interval::withType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like