Truncator::compareToLimit() - Code Metrics - Inspection of "Split processing logic." - vctls/php-interval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cb5f1c...5f5111 )

by Victor

created 2019-10-17 12:07 UTC

Truncator::compareToLimit() A

↳ Parent: Truncator

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	9
c	1
b	0
f	0
nc	3
nop	3
dl	0
loc	11
rs	9.9666

<?php

namespace Vctls\IntervalGraph;


use InvalidArgumentException;

/**
 * Truncate an array of intervals according to a low and high bound.
 *
 * @package Vctls\IntervalGraph
 */
class Truncator
{
    /**
     * Truncate all intervals to the given lower and upper limits.
     *
     * @param array $intervals
     * @param mixed $lowerLimit
     * @param mixed $upperLimit
     * @param bool $padding Add null value intervals between the bounds and the first and last bounds.
     * @return array
     */
    public static function truncate(array $intervals, $lowerLimit = null, $upperLimit = null, $padding = false): array
    {
        $limits = [
            0 => $lowerLimit,
            1 => $upperLimit
        ];
        foreach ($limits as $type => $limit) {
            if (isset($limit)) {
                foreach ($intervals as $key => $interval) {
                    if (self::compareToLimit($interval[$type], $limit, $type)) {
                        if (self::compareToLimit($interval[(int)!$type], $limit, $type)) {
                            // If both bounds are beyond the limit, set the interval to false for removal.
                            $intervals[$key] = false;
                        } else {
                            // If only the outer bound is beyond the limit, set it to the limit value.
                            $intervals[$key][$type] = $limit;
                        }
                    }
                }

                // Remove false elements.
                $intervals = array_filter($intervals);

                // If padding is required and a limit is set and is beyond the limit,
                // add a valueless interval between that bound and the limit.
                if ($padding) {
                    self::pad($intervals, $limit, $type);
                }
            }
        }

        return $intervals;
    }

    /**
     * Pad the interval array if needed, from left OR right depending on the type.
     *
     * @param $intervals
     * @param $value
     * @param $type
     */
    public static function pad(&$intervals, $value, $type): void
    {
        switch ($type) {
            case 0:
                $bound = self::minBound($intervals);
                if (isset($bound) && $bound > $value) {
                    array_unshift($intervals, [$value, $bound]);
                }
                break;
            case 1:
                $bound = self::maxBound($intervals);
                if (isset($bound) && $bound < $value) {
                    $intervals[] = [$bound, $value];
                }
                break;
            default:
                throw new InvalidArgumentException('Type should be 0 (low padding) or 1 (high padding).');
        }
    }

    /**
     * Return the minimum or maximum bound depending on the type.
     *
     * @param $intervals
     * @param int $type 0 (min) or 1 (max)
     * @return mixed
     */
    public static function outerBound($intervals, int $type)
    {
        switch ($type) {
            case 0:
                return self::minBound($intervals);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 1:
                return self::maxBound($intervals);
                break;
            default:
                throw new InvalidArgumentException('Type must be 0 (min) or 1 (max)');
        }
    }

    /**
     * Get the minimum bound in an array of intervals.
     *
     * @param $intervals
     * @return mixed
     */
    public static function minBound($intervals)
    {
        $bounds = array_column($intervals, 0);
        sort($bounds);
        return array_shift($bounds);
    }

    /**
     * Get the maximum bound in an array of intervals.
     *
     * @param $intervals
     * @return mixed
     */
    public static function maxBound($intervals)
    {
        $bounds = array_column($intervals, 1);
        sort($bounds);
        return array_pop($bounds);
    }

    /**
     * Checks if the value is inferior to a lower (type 0) limit,
     * or superior to an upper (type 1) limit.
     *
     * @param $value
     * @param $limit
     * @param int $type 0 (lower limit) or 1 (upper limit)
     * @return bool
     */
    private static function compareToLimit($value, $limit, int $type): bool
    {
        switch ($type) {
            case 0 :
                return $value < $limit;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 1 :
                return $value > $limit;
                break;
            default :
                throw new InvalidArgumentException('Limit type must be 0 (lower) or 1 (upper)');
        }
    }
}


1			<?php
2
3			namespace Vctls\IntervalGraph;
4
5
6			use InvalidArgumentException;
7
8			/**
9			* Truncate an array of intervals according to a low and high bound.
10			*
11			* @package Vctls\IntervalGraph
12			*/
13			class Truncator
14			{
15			/**
16			* Truncate all intervals to the given lower and upper limits.
17			*
18			* @param array $intervals
19			* @param mixed $lowerLimit
20			* @param mixed $upperLimit
21			* @param bool $padding Add null value intervals between the bounds and the first and last bounds.
22			* @return array
23			*/
24			public static function truncate(array $intervals, $lowerLimit = null, $upperLimit = null, $padding = false): array
25			{
26			$limits = [
27			0 => $lowerLimit,
28			1 => $upperLimit
29			];
30			foreach ($limits as $type => $limit) {
31			if (isset($limit)) {
32			foreach ($intervals as $key => $interval) {
33			if (self::compareToLimit($interval[$type], $limit, $type)) {
34			if (self::compareToLimit($interval[(int)!$type], $limit, $type)) {
35			// If both bounds are beyond the limit, set the interval to false for removal.
36			$intervals[$key] = false;
37			} else {
38			// If only the outer bound is beyond the limit, set it to the limit value.
39			$intervals[$key][$type] = $limit;
40			}
41			}
42			}
43
44			// Remove false elements.
45			$intervals = array_filter($intervals);
46
47			// If padding is required and a limit is set and is beyond the limit,
48			// add a valueless interval between that bound and the limit.
49			if ($padding) {
50			self::pad($intervals, $limit, $type);
51			}
52			}
53			}
54
55			return $intervals;
56			}
57
58			/**
59			* Pad the interval array if needed, from left OR right depending on the type.
60			*
61			* @param $intervals
62			* @param $value
63			* @param $type
64			*/
65			public static function pad(&$intervals, $value, $type): void
66			{
67			switch ($type) {
68			case 0:
69			$bound = self::minBound($intervals);
70			if (isset($bound) && $bound > $value) {
71			array_unshift($intervals, [$value, $bound]);
72			}
73			break;
74			case 1:
75			$bound = self::maxBound($intervals);
76			if (isset($bound) && $bound < $value) {
77			$intervals[] = [$bound, $value];
78			}
79			break;
80			default:
81			throw new InvalidArgumentException('Type should be 0 (low padding) or 1 (high padding).');
82			}
83			}
84
85			/**
86			* Return the minimum or maximum bound depending on the type.
87			*
88			* @param $intervals
89			* @param int $type 0 (min) or 1 (max)
90			* @return mixed
91			*/
92			public static function outerBound($intervals, int $type)
93			{
94			switch ($type) {
95			case 0:
96			return self::minBound($intervals);
97			break;
			0 ignored issues – show Unused Code introduced 2019-01-25 16:24 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
98			case 1:
99			return self::maxBound($intervals);
100			break;
101			default:
102			throw new InvalidArgumentException('Type must be 0 (min) or 1 (max)');
103			}
104			}
105
106			/**
107			* Get the minimum bound in an array of intervals.
108			*
109			* @param $intervals
110			* @return mixed
111			*/
112			public static function minBound($intervals)
113			{
114			$bounds = array_column($intervals, 0);
115			sort($bounds);
116			return array_shift($bounds);
117			}
118
119			/**
120			* Get the maximum bound in an array of intervals.
121			*
122			* @param $intervals
123			* @return mixed
124			*/
125			public static function maxBound($intervals)
126			{
127			$bounds = array_column($intervals, 1);
128			sort($bounds);
129			return array_pop($bounds);
130			}
131
132			/**
133			* Checks if the value is inferior to a lower (type 0) limit,
134			* or superior to an upper (type 1) limit.
135			*
136			* @param $value
137			* @param $limit
138			* @param int $type 0 (lower limit) or 1 (upper limit)
139			* @return bool
140			*/
141			private static function compareToLimit($value, $limit, int $type): bool
142			{
143			switch ($type) {
144			case 0 :
145			return $value < $limit;
146			break;
			0 ignored issues – show Unused Code introduced 2019-01-25 16:24 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
147			case 1 :
148			return $value > $limit;
149			break;
150			default :
151			throw new InvalidArgumentException('Limit type must be 0 (lower) or 1 (upper)');
152			}
153			}
154			}
155

vctls / php-interval-graph

Push — master ( cb5f1c...5f5111 )

Truncator::compareToLimit() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like