AbstractRange::getRangeType() - Code Metrics - mlocati/ip-lib - Measure and Improve Code Quality continuously with Scrutinizer

AbstractRange::getRangeType() B
last analyzed 2025-02-04 17:48 UTC

↳ 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;

/**
 * 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})");
        }
        if ($startIp instanceof IPv4) {
            $one = IPv4::fromBytes(array(0, 0, 0, 1));
        } elseif ($startIp instanceof IPv6) {
            $one = IPv6::fromBytes(array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1));
        }
        $delta = $one->shift($networkPrefix - $maxPrefix);

        $result = array();
        while (true) {
            $range = Subnet::parseString("{$startIp}/{$networkPrefix}");
            if (!$forceSubnet && $this instanceof Pattern) {
                $range = $range->asPattern() ?: $range;
            }
            $result[] = $range;
            $startIp = $startIp->add($delta);
            if ($startIp === null || !$this->contains($startIp)) {
                break;
            }
        }

        return $result;
    }
}


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
12		/**
13		* Base class for range classes.
14		*/
15		abstract class AbstractRange implements RangeInterface
16		{
17		/**
18		* {@inheritdoc}
19		*
20		* @see \IPLib\Range\RangeInterface::getRangeType()
21		*/
22	242	public function getRangeType()
23		{
24	242	if ($this->rangeType === null) {
25	242	$addressType = $this->getAddressType();
26	242	if ($addressType === AddressType::T_IPv6 && Subnet::get6to4()->containsRange($this)) {
27	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...
28		} else {
29	233	switch ($addressType) {
30		case AddressType::T_IPv4:
31	170	$defaultType = IPv4::getDefaultReservedRangeType();
32	170	$reservedRanges = IPv4::getReservedRanges();
33	170	break;
34		case AddressType::T_IPv6:
35	63	$defaultType = IPv6::getDefaultReservedRangeType();
36	63	$reservedRanges = IPv6::getReservedRanges();
37	63	break;
38		default:
39		throw new \Exception('@todo'); // @codeCoverageIgnore
40		}
41	233	$rangeType = null;
42	233	foreach ($reservedRanges as $reservedRange) {
43	233	$rangeType = $reservedRange->getRangeType($this);
44	233	if ($rangeType !== null) {
45	198	break;
46		}
47		}
48	233	$this->rangeType = $rangeType === null ? $defaultType : $rangeType;
49		}
50		}
51
52	242	return $this->rangeType === false ? null : $this->rangeType;
53		}
54
55		/**
56		* {@inheritdoc}
57		*
58		* @see \IPLib\Range\RangeInterface::getAddressAtOffset()
59		*/
60	15	public function getAddressAtOffset($n)
61		{
62	15	if (!is_int($n)) {
63	2	return null;
64		}
65
66	13	$address = null;
67	13	if ($n >= 0) {
68	8	$start = Factory::parseAddressString($this->getComparableStartString());
69	8	$address = $start->getAddressAtOffset($n);
70		} else {
71	5	$end = Factory::parseAddressString($this->getComparableEndString());
72	5	$address = $end->getAddressAtOffset($n + 1);
73		}
74
75	13	if ($address === null) {
76	1	return null;
77		}
78
79	12	return $this->contains($address) ? $address : null;
80		}
81
82		/**
83		* {@inheritdoc}
84		*
85		* @see \IPLib\Range\RangeInterface::contains()
86		*/
87	271	public function contains(AddressInterface $address)
88		{
89	271	$result = false;
90	271	if ($address->getAddressType() === $this->getAddressType()) {
91	271	$cmp = $address->getComparableString();
92	271	$from = $this->getComparableStartString();
93	271	if ($cmp >= $from) {
94	266	$to = $this->getComparableEndString();
95	266	if ($cmp <= $to) {
96	222	$result = true;
97		}
98		}
99		}
100
101	271	return $result;
102		}
103
104		/**
105		* {@inheritdoc}
106		*
107		* @see \IPLib\Range\RangeInterface::containsRange()
108		*/
109	89	public function containsRange(RangeInterface $range)
110		{
111	89	$result = false;
112	89	if ($range->getAddressType() === $this->getAddressType()) {
113	89	$myStart = $this->getComparableStartString();
114	89	$itsStart = $range->getComparableStartString();
115	89	if ($itsStart >= $myStart) {
116	51	$myEnd = $this->getComparableEndString();
117	51	$itsEnd = $range->getComparableEndString();
118	51	if ($itsEnd <= $myEnd) {
119	21	$result = true;
120		}
121		}
122		}
123
124	89	return $result;
125		}
126
127		/**
128		* {@inheritdoc}
129		*
130		* @see \IPLib\Range\RangeInterface::split()
131		*/
132	65	public function split($networkPrefix, $forceSubnet = false)
133		{
134	65	$networkPrefix = (int) $networkPrefix;
135	65	$myNetworkPrefix = $this->getNetworkPrefix();
136	65	if ($networkPrefix === $myNetworkPrefix) {
137		return array(
138	18	$forceSubnet ? $this->asSubnet() : $this,
139		);
140		}
141	47	if ($networkPrefix < $myNetworkPrefix) {
142	16	throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be smaller than the network prefix of the range ({$myNetworkPrefix})");
143		}
144	31	$startIp = $this->getStartAddress();
145	31	$maxPrefix = $startIp::getNumberOfBits();
146	31	if ($networkPrefix > $maxPrefix) {
147	13	throw new OutOfBoundsException("The value of the \$networkPrefix parameter can't be larger than the maximum network prefix of the range ({$maxPrefix})");
148		}
149	18	if ($startIp instanceof IPv4) {
150	14	$one = IPv4::fromBytes(array(0, 0, 0, 1));
151	4	} elseif ($startIp instanceof IPv6) {
152	4	$one = IPv6::fromBytes(array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1));
153		}
154	18	$delta = $one->shift($networkPrefix - $maxPrefix);
		0 ignored issues – show Comprehensibility Best Practice introduced 2025-02-04 17:36 UTC by Report Bug Copy Issue Report The variable `$one` does not seem to be defined for all execution paths leading up to this point. Loading history...
155	18	$result = array();
156	18	while (true) {
157	18	$range = Subnet::parseString("{$startIp}/{$networkPrefix}");
158	18	if (!$forceSubnet && $this instanceof Pattern) {
159	6	$range = $range->asPattern() ?: $range;
160		}
161	18	$result[] = $range;
162	18	$startIp = $startIp->add($delta);
163	18	if ($startIp === null \|\| !$this->contains($startIp)) {
164	18	break;
165		}
166		}
167
168	18	return $result;
169		}
170		}
171

mlocati / ip-lib

AbstractRange::getRangeType() B last analyzed 2025-02-04 17:48 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AbstractRange::getRangeType() B
last analyzed 2025-02-04 17:48 UTC