AbstractRange::getRangeType() - Code Metrics - Inspection of "Add `split` and `getNetworkPrefix` to IP ranges (#..." - mlocati/ip-lib - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — main (86ec0c)

by Michele

created 2025-02-04 12:12 UTC

AbstractRange::getRangeType() B

↳ Parent: AbstractRange

Complexity

Conditions	10
Paths	29

Size

Total Lines	31
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	19
CRAP Score	10

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	10
eloc	23
nc	29
nop	0
dl	0
loc	31
ccs	19
cts	19
cp	1
crap	10
rs	7.6666
c	1
b	0
f	0

How to fix Complexity

<?php

namespace IPLib\Range;

use IPLib\Address\AddressInterface;
use IPLib\Address\IPv4;
use IPLib\Address\IPv6;
use IPLib\Address\Type as AddressType;
use IPLib\Factory;
use OutOfBoundsException;
use OverflowException;

/**
 * Base class for range classes.
 */
abstract class AbstractRange implements RangeInterface
{
    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Range\RangeInterface::getRangeType()
     */
    public function getRangeType()
    {
        if ($this->rangeType === null) {
            $addressType = $this->getAddressType();
            if ($addressType === AddressType::T_IPv6 && Subnet::get6to4()->containsRange($this)) {
                $this->rangeType = Factory::getRangeFromBoundaries($this->fromAddress->toIPv4(), $this->toAddress->toIPv4())->getRangeType();

            } else {
                switch ($addressType) {
                    case AddressType::T_IPv4:
                        $defaultType = IPv4::getDefaultReservedRangeType();
                        $reservedRanges = IPv4::getReservedRanges();
                        break;
                    case AddressType::T_IPv6:
                        $defaultType = IPv6::getDefaultReservedRangeType();
                        $reservedRanges = IPv6::getReservedRanges();
                        break;
                    default:
                        throw new \Exception('@todo'); // @codeCoverageIgnore
                }
                $rangeType = null;
                foreach ($reservedRanges as $reservedRange) {
                    $rangeType = $reservedRange->getRangeType($this);
                    if ($rangeType !== null) {
                        break;
                    }
                }
                $this->rangeType = $rangeType === null ? $defaultType : $rangeType;
            }
        }

        return $this->rangeType === false ? null : $this->rangeType;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Range\RangeInterface::getAddressAtOffset()
     */
    public function getAddressAtOffset($n)
    {
        if (!is_int($n)) {
            return null;
        }

        $address = null;
        if ($n >= 0) {
            $start = Factory::parseAddressString($this->getComparableStartString());
            $address = $start->getAddressAtOffset($n);
        } else {
            $end = Factory::parseAddressString($this->getComparableEndString());
            $address = $end->getAddressAtOffset($n + 1);
        }

        if ($address === null) {
            return null;
        }

        return $this->contains($address) ? $address : null;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Range\RangeInterface::contains()
     */
    public function contains(AddressInterface $address)
    {
        $result = false;
        if ($address->getAddressType() === $this->getAddressType()) {
            $cmp = $address->getComparableString();
            $from = $this->getComparableStartString();
            if ($cmp >= $from) {
                $to = $this->getComparableEndString();
                if ($cmp <= $to) {
                    $result = true;
                }
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Range\RangeInterface::containsRange()
     */
    public function containsRange(RangeInterface $range)
    {
        $result = false;
        if ($range->getAddressType() === $this->getAddressType()) {
            $myStart = $this->getComparableStartString();
            $itsStart = $range->getComparableStartString();
            if ($itsStart >= $myStart) {
                $myEnd = $this->getComparableEndString();
                $itsEnd = $range->getComparableEndString();
                if ($itsEnd <= $myEnd) {
                    $result = true;
                }
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Range\RangeInterface::split()
     */
    public function split($networkPrefix, $forceSubnet = false)
    {
        $networkPrefix = (int) $networkPrefix;
        $myNetworkPrefix = $this->getNetworkPrefix();
        if ($networkPrefix === $myNetworkPrefix) {
            return array(
                $forceSubnet ? $this->asSubnet() : $this,
            );
        }
        if ($networkPrefix < $myNetworkPrefix) {
            throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be smaller than the network prefix of the range ({$myNetworkPrefix})");
        }
        $startIp = $this->getStartAddress();
        $maxPrefix = $startIp::getNumberOfBits();
        if ($networkPrefix > $maxPrefix) {
            throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be larger than the maximum network prefix of the range ({$maxPrefix})");
        }

        $systemBitness = PHP_INT_SIZE * 8;
        $minPrefixByBitness = $maxPrefix - $systemBitness + 2;
        if ($networkPrefix < $minPrefixByBitness) {
            throw new OverflowException("The value of \$networkPrefix leads to too large ranges for the current machine bitness (you can use a value of at least {$minPrefixByBitness})");
        }

        $chunkSize = pow(2, $maxPrefix - $networkPrefix);
        $maxIndex = $this->getSize() / $chunkSize;
        $data = array();
        for ($i = 0; $i < $maxIndex; $i++) {
            $range = Subnet::parseString(sprintf('%s/%d', $startIp, $networkPrefix));
            if (!$forceSubnet && $this instanceof Pattern) {
                $range = $range->asPattern() ?: $range;
            }
            $data[] = $range;
            $startIp = $startIp->getAddressAtOffset($chunkSize);
        }

        return $data;
    }
}


1		<?php
2
3		namespace IPLib\Range;
4
5		use IPLib\Address\AddressInterface;
6		use IPLib\Address\IPv4;
7		use IPLib\Address\IPv6;
8		use IPLib\Address\Type as AddressType;
9		use IPLib\Factory;
10		use OutOfBoundsException;
11		use OverflowException;
12
13		/**
14		* Base class for range classes.
15		*/
16		abstract class AbstractRange implements RangeInterface
17		{
18		/**
19		* {@inheritdoc}
20		*
21		* @see \IPLib\Range\RangeInterface::getRangeType()
22		*/
23	242	public function getRangeType()
24		{
25	242	if ($this->rangeType === null) {
26	242	$addressType = $this->getAddressType();
27	242	if ($addressType === AddressType::T_IPv6 && Subnet::get6to4()->containsRange($this)) {
28	9	$this->rangeType = Factory::getRangeFromBoundaries($this->fromAddress->toIPv4(), $this->toAddress->toIPv4())->getRangeType();
		0 ignored issues – show Bug Best Practice introduced 2025-02-04 12:20 UTC by Report Bug Copy Issue Report The property `rangeType` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
29		} else {
30	233	switch ($addressType) {
31		case AddressType::T_IPv4:
32	170	$defaultType = IPv4::getDefaultReservedRangeType();
33	170	$reservedRanges = IPv4::getReservedRanges();
34	170	break;
35		case AddressType::T_IPv6:
36	63	$defaultType = IPv6::getDefaultReservedRangeType();
37	63	$reservedRanges = IPv6::getReservedRanges();
38	63	break;
39		default:
40		throw new \Exception('@todo'); // @codeCoverageIgnore
41		}
42	233	$rangeType = null;
43	233	foreach ($reservedRanges as $reservedRange) {
44	233	$rangeType = $reservedRange->getRangeType($this);
45	233	if ($rangeType !== null) {
46	198	break;
47		}
48		}
49	233	$this->rangeType = $rangeType === null ? $defaultType : $rangeType;
50		}
51		}
52
53	242	return $this->rangeType === false ? null : $this->rangeType;
54		}
55
56		/**
57		* {@inheritdoc}
58		*
59		* @see \IPLib\Range\RangeInterface::getAddressAtOffset()
60		*/
61	15	public function getAddressAtOffset($n)
62		{
63	15	if (!is_int($n)) {
64	2	return null;
65		}
66
67	13	$address = null;
68	13	if ($n >= 0) {
69	8	$start = Factory::parseAddressString($this->getComparableStartString());
70	8	$address = $start->getAddressAtOffset($n);
71		} else {
72	5	$end = Factory::parseAddressString($this->getComparableEndString());
73	5	$address = $end->getAddressAtOffset($n + 1);
74		}
75
76	13	if ($address === null) {
77	1	return null;
78		}
79
80	12	return $this->contains($address) ? $address : null;
81		}
82
83		/**
84		* {@inheritdoc}
85		*
86		* @see \IPLib\Range\RangeInterface::contains()
87		*/
88	253	public function contains(AddressInterface $address)
89		{
90	253	$result = false;
91	253	if ($address->getAddressType() === $this->getAddressType()) {
92	253	$cmp = $address->getComparableString();
93	253	$from = $this->getComparableStartString();
94	253	if ($cmp >= $from) {
95	248	$to = $this->getComparableEndString();
96	248	if ($cmp <= $to) {
97	204	$result = true;
98		}
99		}
100		}
101
102	253	return $result;
103		}
104
105		/**
106		* {@inheritdoc}
107		*
108		* @see \IPLib\Range\RangeInterface::containsRange()
109		*/
110	89	public function containsRange(RangeInterface $range)
111		{
112	89	$result = false;
113	89	if ($range->getAddressType() === $this->getAddressType()) {
114	89	$myStart = $this->getComparableStartString();
115	89	$itsStart = $range->getComparableStartString();
116	89	if ($itsStart >= $myStart) {
117	51	$myEnd = $this->getComparableEndString();
118	51	$itsEnd = $range->getComparableEndString();
119	51	if ($itsEnd <= $myEnd) {
120	21	$result = true;
121		}
122		}
123		}
124
125	89	return $result;
126		}
127
128		/**
129		* {@inheritdoc}
130		*
131		* @see \IPLib\Range\RangeInterface::split()
132		*/
133	65	public function split($networkPrefix, $forceSubnet = false)
134		{
135	65	$networkPrefix = (int) $networkPrefix;
136	65	$myNetworkPrefix = $this->getNetworkPrefix();
137	65	if ($networkPrefix === $myNetworkPrefix) {
138		return array(
139	18	$forceSubnet ? $this->asSubnet() : $this,
140		);
141		}
142	47	if ($networkPrefix < $myNetworkPrefix) {
143	16	throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be smaller than the network prefix of the range ({$myNetworkPrefix})");
144		}
145	31	$startIp = $this->getStartAddress();
146	31	$maxPrefix = $startIp::getNumberOfBits();
147	31	if ($networkPrefix > $maxPrefix) {
148	13	throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be larger than the maximum network prefix of the range ({$maxPrefix})");
149		}
150
151	18	$systemBitness = PHP_INT_SIZE * 8;
152	18	$minPrefixByBitness = $maxPrefix - $systemBitness + 2;
153	18	if ($networkPrefix < $minPrefixByBitness) {
154	1	throw new OverflowException("The value of \$networkPrefix leads to too large ranges for the current machine bitness (you can use a value of at least {$minPrefixByBitness})");
155		}
156
157	17	$chunkSize = pow(2, $maxPrefix - $networkPrefix);
158	17	$maxIndex = $this->getSize() / $chunkSize;
159	17	$data = array();
160	17	for ($i = 0; $i < $maxIndex; $i++) {
161	17	$range = Subnet::parseString(sprintf('%s/%d', $startIp, $networkPrefix));
162	17	if (!$forceSubnet && $this instanceof Pattern) {
163	6	$range = $range->asPattern() ?: $range;
164		}
165	17	$data[] = $range;
166	17	$startIp = $startIp->getAddressAtOffset($chunkSize);
167		}
168
169	17	return $data;
170		}
171		}
172

mlocati / ip-lib

Branch — main (86ec0c)

AbstractRange::getRangeType() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like