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

Code Duplication Length = 271-271 lines in 2 locations

src/IPv4/IPv4Interval.php 1 location


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


src/Number/NumberInterval.php 1 location


use GpsLab\Component\Interval\IntervalPointInterface;
use GpsLab\Component\Interval\IntervalType;

class NumberInterval implements ComparableIntervalInterface
{
    /**
     * @var string
     */
    const REGEXP = '/^
        (?:\(|\[)        # start type char
        \s*
        (?<start>\-?\d+) # start point
        \s*,\s*          # separator
        (?<end>\-?\d+)   # end point
        \s*
        (?:\)|\])        # end type char
    $/x';

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

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

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

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

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

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

    /**
     * @param int|float $start
     * @param int|float $end
     * @param IntervalType $type
     *
     * @return self
     */
    public static function create($start, $end, IntervalType $type)
    {
        return new self(new NumberIntervalPoint($start), new NumberIntervalPoint($end), $type);
    }

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

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

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

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

    /**
     * Create interval from string.
     *
     * Example formats:
     *   [0, 5]
     *   (-3, 2]
     *   [-3, -1)
     *   (3, 9)
     *
     * 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('[N, N]', $string);
        }

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

    /**
     * @param int|float $point
     *
     * @return bool
     */
    public function contains($point)
    {
        return $this->comparator->contains(new NumberIntervalPoint($point));
    }

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

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

    /**
     * The point is before the interval
     *
     * @param int|float $point
     *
     * @return bool
     */
    public function before($point)
    {
        return $this->comparator->before(new NumberIntervalPoint($point));
    }

    /**
     * The point is after the interval
     *
     * @param int|float $point
     *
     * @return bool
     */
    public function after($point)
    {
        return $this->comparator->after(new NumberIntervalPoint($point));
    }

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

    /**
     * @return int|float
     */
    public function start()
    {
        return $this->start->value();
    }

    /**
     * @return int|float
     */
    public function end()
    {
        return $this->end->value();
    }

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

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

    /**
     * Returns a copy of this Interval with the start point altered.
     *
     * @param IntervalPointInterface|NumberIntervalPoint $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|NumberIntervalPoint $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);
    }
}


		@@ 19-289 (lines=271) @@
16		use GpsLab\Component\Interval\IntervalPointInterface;
17		use GpsLab\Component\Interval\IntervalType;
18
19		class IPv4Interval implements ComparableIntervalInterface
20		{
21		/**
22		* @var string
23		*/
24		const REGEXP = '/^
25		(?:\(\|\[) # start type char
26		\s*
27		(?<start>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3}) # start point
28		\s,\s # separator
29		(?<end>\d{1-3}\.\d{1-3}\.\d{1-3}\.\d{1-3}) # end point
30		\s*
31		(?:\)\|\]) # end type char
32		$/x';
33
34		/**
35		* @var IntervalType
36		*/
37		private $type;
38
39		/**
40		* @var IntervalComparator
41		*/
42		private $comparator;
43
44		/**
45		* @var IPv4IntervalPoint
46		*/
47		private $start;
48
49		/**
50		* @var IPv4IntervalPoint
51		*/
52		private $end;
53
54		/**
55		* @param IPv4IntervalPoint $start
56		* @param IPv4IntervalPoint $end
57		* @param IntervalType $type
58		*/
59		private function __construct(IPv4IntervalPoint $start, IPv4IntervalPoint $end, IntervalType $type)
60		{
61		if ($start->gte($end)) {
62		throw IncorrectIntervalException::create();
63		}
64
65		$this->type = $type;
66		$this->start = $start;
67		$this->end = $end;
68		$this->comparator = new IntervalComparator($this);
69		}
70
71		/**
72		* @param string $start
73		* @param string $end
74		* @param IntervalType $type
75		*
76		* @return self
77		*/
78		public static function create($start, $end, IntervalType $type)
79		{
80		return new self(new IPv4IntervalPoint($start), new IPv4IntervalPoint($end), $type);
81		}
82
83		/**
84		* @param string $start
85		* @param string $end
86		*
87		* @return self
88		*/
89		public static function closed($start, $end)
90		{
91		return static::create($start, $end, IntervalType::closed());
92		}
93
94		/**
95		* @param string $start
96		* @param string $end
97		*
98		* @return self
99		*/
100		public static function halfClosed($start, $end)
101		{
102		return static::create($start, $end, IntervalType::halfClosed());
103		}
104
105		/**
106		* @param string $start
107		* @param string $end
108		*
109		* @return self
110		*/
111		public static function halfOpen($start, $end)
112		{
113		return static::create($start, $end, IntervalType::halfOpen());
114		}
115
116		/**
117		* @param string $start
118		* @param string $end
119		*
120		* @return self
121		*/
122		public static function open($start, $end)
123		{
124		return static::create($start, $end, IntervalType::open());
125		}
126
127		/**
128		* Create interval from string.
129		*
130		* Example formats for all interval types:
131		* [10.0.1.0, 10.0.1.255]
132		* (10.0.0.0, 10.255.255.255]
133		* [172.16.0.0, 172.31.255.255)
134		* (192.168.0.0, 192.168.255.255)
135		*
136		* Spaces are ignored in format.
137		*
138		* @param string $string
139		*
140		* @return self
141		*/
142		public static function fromString($string)
143		{
144		if (!preg_match(self::REGEXP, $string, $match)) {
145		throw InvalidIntervalFormatException::create('[0.0.0.0, 255.255.255.255]', $string);
146		}
147
148		return self::create($match['start'], $match['end'], IntervalType::fromString($string));
149		}
150
151		/**
152		* @param string $point
153		*
154		* @return bool
155		*/
156		public function contains($point)
157		{
158		return $this->comparator->contains(new IPv4IntervalPoint($point));
159		}
160
161		/**
162		* @param IPv4Interval $interval
163		* @param bool $check_interval_type
164		*
165		* @return bool
166		*/
167		public function intersects(IPv4Interval $interval, $check_interval_type = true)
168		{
169		return $this->comparator->intersects($interval, $check_interval_type);
170		}
171
172		/**
173		* @param IPv4Interval $interval
174		*
175		* @return IPv4Interval\|null
176		*/
177		public function intersection(IPv4Interval $interval)
178		{
179		return $this->comparator->intersection($interval);
180		}
181
182		/**
183		* The point is before the interval
184		*
185		* @param string $point
186		*
187		* @return bool
188		*/
189		public function before($point)
190		{
191		return $this->comparator->before(new IPv4IntervalPoint($point));
192		}
193
194		/**
195		* The point is after the interval
196		*
197		* @param string $point
198		*
199		* @return bool
200		*/
201		public function after($point)
202		{
203		return $this->comparator->after(new IPv4IntervalPoint($point));
204		}
205
206		/**
207		* @return IntervalType
208		*/
209		public function type()
210		{
211		return $this->type;
212		}
213
214		/**
215		* @return string
216		*/
217		public function start()
218		{
219		return (string)$this->start;
220		}
221
222		/**
223		* @return string
224		*/
225		public function end()
226		{
227		return (string)$this->end;
228		}
229
230		/**
231		* @return IPv4IntervalPoint
232		*/
233		public function startPoint()
234		{
235		return $this->start;
236		}
237
238		/**
239		* @return IPv4IntervalPoint
240		*/
241		public function endPoint()
242		{
243		return $this->end;
244		}
245
246		/**
247		* Returns a copy of this Interval with the start point altered.
248		*
249		* @param IntervalPointInterface\|IPv4IntervalPoint $start
250		*
251		* @return self
252		*/
253		public function withStart(IntervalPointInterface $start)
254		{
255		return new self($start, $this->end, $this->type);
256		}
257
258		/**
259		* Returns a copy of this Interval with the end point altered.
260		*
261		* @param IntervalPointInterface\|IPv4IntervalPoint $end
262		*
263		* @return self
264		*/
265		public function withEnd(IntervalPointInterface $end)
266		{
267		return new self($this->start, $end, $this->type);
268		}
269
270		/**
271		* Returns a copy of this Interval with the interval type altered.
272		*
273		* @param IntervalType $type
274		*
275		* @return self
276		*/
277		public function withType(IntervalType $type)
278		{
279		return new self($this->start, $this->end, $type);
280		}
281
282		/**
283		* @return string
284		*/
285		public function __toString()
286		{
287		return $this->type->getReadable($this);
288		}
289		}
290

gpslab / interval

Code Duplication Length = 271-271 lines in 2 locations

src/IPv4/IPv4Interval.php 1 location

src/Number/NumberInterval.php 1 location