mappings.php ➔ get_mapping() - Code Metrics - zicht/itertools - Measure and Improve Code Quality continuously with Scrutinizer

mappings.php ➔ get_mapping() C
last analyzed 2021-03-29 13:12 UTC

↳ Parent: Project

Complexity

Conditions	13
Paths	13

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	13
nc	13
nop	1
dl	0
loc	35
rs	6.6166
c	0
b	0
f	0

How to fix Complexity

<?php
/**
 * @copyright Zicht Online <http://zicht.nl>
 */

namespace Zicht\Itertools\mappings;

use Zicht\Itertools\util\Mappings;

/**
 * Returns a closure that strips any matching $CHARS from the left of the input string
 *
 * @param string $chars
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::lstrip($chars), will be removed in version 3.0
 */
function lstrip($chars = " \t\n\r\0\x0B")
{
    return Mappings::lstrip($chars);
}

/**
 * Returns a closure that strips any matching $CHARS from the right of the input string
 *
 * @param string $chars
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::lstrip($chars), will be removed in version 3.0
 */
function rstrip($chars = " \t\n\r\0\x0B")
{
    return Mappings::rstrip($chars);
}

/**
 * Returns a closure that strips any matching $CHARS from the left and right of the input string
 *
 * @param string $chars
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::strip($chars), will be removed in version 3.0
 */
function strip($chars = " \t\n\r\0\x0B")
{
    return Mappings::strip($chars);
}

/**
 * Returns a closure that returns the length of the input
 *
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::length(), will be removed in version 3.0
 */
function length()
{
    return Mappings::length();
}

/**
 * Returns a closure that returns the key
 *
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::key(), will be removed in version 3.0
 */
function key()
{
    return Mappings::key();
}

/**
 * Returns a closure that returns the string value lower cased
 *
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::lower(), will be removed in version 3.0
 */
function lower()
{
    return Mappings::lower();
}

/**
 * Returns a closure that returns the string value upper cased
 *
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::upper(), will be removed in version 3.0
 */
function upper()
{
    return Mappings::upper();
}

/**
 * Returns a closure that returns the value cast to a string
 *
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::string(), will be removed in version 3.0
 */
function string()
{
    return Mappings::string();
}

/**
 * Returns a closure that returns the value as a json_encoded string
 *
 * @param int $options
 * @param int $depth
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::jsonEncode($options, $depth), will be removed in version 3.0
 */
function json_encode($options = 0, $depth = 512)
{
    return Mappings::jsonEncode($options, $depth);
}

/**
 * Returns a closure that returns the json_encoded value as decoded value
 *
 * @param boolean $assoc
 * @param int $depth
 * @param int $options
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::jsonDecode($assoc, $options, $depth), will be removed in version 3.0
 */
function json_decode($assoc = false, $depth = 512, $options = 0)
{
    return Mappings::jsonDecode($assoc, $options, $depth);
}

/**
 * Returns a closure that applies multiple $STRATEGIES to the value and returns the results
 *
 * > $compute = function ($value, $key) {
 * >    return 'some computation result';
 * > };
 * > $list = iter\iterable([new Data(1), new Data(2), new Data(3)]);
 * > $list->map(select(['data' => null, 'id' => 'Identifier', 'desc' => 'Value.DescriptionName', 'comp' => $compute]));
 * [
 *    [
 *       'data' => Data(1),
 *       'id' => Data(1)->Identifier,
 *       'desc' => Data(1)->Value->DescriptionName,
 *       'comp' => $compute(Data(1), 0),
 *    ],
 *    ...
 *    [
 *       'data' => Data(3),
 *       'id' => Data(3)->Identifier,
 *       'desc' => Data(3)->Value->DescriptionName,
 *       'comp' => $compute(Data(3), 2),
 *    ],
 * ]
 *
 * @param array|object $mappings
 * @param null|string|\Closure $strategy
 * @param boolean $discardNull
 * @param boolean $discardEmptyContainer
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::select($mappings, $strategy, $discardNull, $discardEmptyContainer), will be removed in version 3.0
 */
function select($mappings, $strategy = null, $discardNull = false, $discardEmptyContainer = false)
{
    return Mappings::select($mappings, $strategy, $discardNull, $discardEmptyContainer);
}

/**
 * Returns a closure that returns random integer numbers between $MIN and $MAX
 *
 * @param int $min
 * @param null|int $max
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::random($min, $max), will be removed in version 3.0
 */
function random($min = 0, $max = null)
{
    return Mappings::random($min, $max);
}

/**
 * Returns a closure that returns either the class name, given an object, or otherwise the type
 *
 * @param null|string|\Closure $strategy
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::type($strategy), will be removed in version 3.0
 */
function type($strategy = null)
{
    return Mappings::type($strategy);
}

/**
 * Returns a closure that calls the mapping on each element once.
 *
 * > $compute = function ($value, $key) {
 * >    return 'some expensive computation result';
 * > };
 * > $list = iter\iterable([['id' => 42, ...], ['id' => 43, ...], ['id' => 42, ...]]);
 * > $list->map(cache($compute, 'id'));
 * [
 *    $compute(['id' => 42, ...]), // <-- calls the $compute method
 *    $compute(['id' => 43, ...]), // <-- calls the $compute method
 *    $compute(['id' => 42, ...])  // <-- does not call, instead, populates with cached values
 * ]
 *
 * @param null|string|\Closure $mapping
 * @param null|string|\Closure $strategy
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::cache($mapping, $strategy), will be removed in version 3.0
 */
function cache($mapping, $strategy = null)
{
    return Mappings::cache($mapping, $strategy);
}

/**
 * Returns a closure that returns the same value every time it is called.
 *
 * @param null|string|int|float|bool|object|array $value
 * @return \Closure
 * @deprecated Use \Zicht\Itertools\util\Mappings::constant($value), will be removed in version 3.0
 */
function constant($value)
{
    return Mappings::constant($value);
}

/**
 * Returns a mapping closure
 *
 * @param string $name
 * @return \Closure
 * @throws \InvalidArgumentException
 * @deprecated please use the mapping functions directly, will be removed in version 3.0
 */
function get_mapping($name /* [argument, [arguments, ...] */)
{
    if (is_string($name)) {
        switch ($name) {
            case 'ltrim':
            case 'lstrip':
                return call_user_func_array('\Zicht\Itertools\mappings\lstrip', array_slice(func_get_args(), 1));

            case 'rtrim':
            case 'rstrip':
                return call_user_func_array('\Zicht\Itertools\mappings\rstrip', array_slice(func_get_args(), 1));

            case 'trim':
            case 'strip':
                return call_user_func_array('\Zicht\Itertools\mappings\strip', array_slice(func_get_args(), 1));

            case 'length':
                return length();

            case 'key':
                return key();

            case 'select':
                return call_user_func_array('\Zicht\Itertools\mappings\select', array_slice(func_get_args(), 1));

            case 'random':
                return call_user_func_array('\Zicht\Itertools\mappings\random', array_slice(func_get_args(), 1));

            case 'type':
                return call_user_func_array('\Zicht\Itertools\mappings\type', array_slice(func_get_args(), 1));
        }
    }

    throw new \InvalidArgumentException(sprintf('$NAME "%s" is not a valid mapping.', $name));
}

/**
 * @param string $name
 * @return \Closure
 * @throws \InvalidArgumentException
 * @deprecated please use the mapping functions directly, will be removed in version 3.0
 */
function getMapping($name /* [argument, [arguments, ...] */) // phpcs:ignore Zicht.NamingConventions.Functions.GlobalNaming

{
    return call_user_func_array('\Zicht\Itertools\mappings\get_mapping', func_get_args());
}


1			<?php
2			/**
3			* @copyright Zicht Online <http://zicht.nl>
4			*/
5
6			namespace Zicht\Itertools\mappings;
7
8			use Zicht\Itertools\util\Mappings;
9
10			/**
11			* Returns a closure that strips any matching $CHARS from the left of the input string
12			*
13			* @param string $chars
14			* @return \Closure
15			* @deprecated Use \Zicht\Itertools\util\Mappings::lstrip($chars), will be removed in version 3.0
16			*/
17			function lstrip($chars = " \t\n\r\0\x0B")
18			{
19			return Mappings::lstrip($chars);
20			}
21
22			/**
23			* Returns a closure that strips any matching $CHARS from the right of the input string
24			*
25			* @param string $chars
26			* @return \Closure
27			* @deprecated Use \Zicht\Itertools\util\Mappings::lstrip($chars), will be removed in version 3.0
28			*/
29			function rstrip($chars = " \t\n\r\0\x0B")
30			{
31			return Mappings::rstrip($chars);
32			}
33
34			/**
35			* Returns a closure that strips any matching $CHARS from the left and right of the input string
36			*
37			* @param string $chars
38			* @return \Closure
39			* @deprecated Use \Zicht\Itertools\util\Mappings::strip($chars), will be removed in version 3.0
40			*/
41			function strip($chars = " \t\n\r\0\x0B")
42			{
43			return Mappings::strip($chars);
44			}
45
46			/**
47			* Returns a closure that returns the length of the input
48			*
49			* @return \Closure
50			* @deprecated Use \Zicht\Itertools\util\Mappings::length(), will be removed in version 3.0
51			*/
52			function length()
53			{
54			return Mappings::length();
55			}
56
57			/**
58			* Returns a closure that returns the key
59			*
60			* @return \Closure
61			* @deprecated Use \Zicht\Itertools\util\Mappings::key(), will be removed in version 3.0
62			*/
63			function key()
64			{
65			return Mappings::key();
66			}
67
68			/**
69			* Returns a closure that returns the string value lower cased
70			*
71			* @return \Closure
72			* @deprecated Use \Zicht\Itertools\util\Mappings::lower(), will be removed in version 3.0
73			*/
74			function lower()
75			{
76			return Mappings::lower();
77			}
78
79			/**
80			* Returns a closure that returns the string value upper cased
81			*
82			* @return \Closure
83			* @deprecated Use \Zicht\Itertools\util\Mappings::upper(), will be removed in version 3.0
84			*/
85			function upper()
86			{
87			return Mappings::upper();
88			}
89
90			/**
91			* Returns a closure that returns the value cast to a string
92			*
93			* @return \Closure
94			* @deprecated Use \Zicht\Itertools\util\Mappings::string(), will be removed in version 3.0
95			*/
96			function string()
97			{
98			return Mappings::string();
99			}
100
101			/**
102			* Returns a closure that returns the value as a json_encoded string
103			*
104			* @param int $options
105			* @param int $depth
106			* @return \Closure
107			* @deprecated Use \Zicht\Itertools\util\Mappings::jsonEncode($options, $depth), will be removed in version 3.0
108			*/
109			function json_encode($options = 0, $depth = 512)
110			{
111			return Mappings::jsonEncode($options, $depth);
112			}
113
114			/**
115			* Returns a closure that returns the json_encoded value as decoded value
116			*
117			* @param boolean $assoc
118			* @param int $depth
119			* @param int $options
120			* @return \Closure
121			* @deprecated Use \Zicht\Itertools\util\Mappings::jsonDecode($assoc, $options, $depth), will be removed in version 3.0
122			*/
123			function json_decode($assoc = false, $depth = 512, $options = 0)
124			{
125			return Mappings::jsonDecode($assoc, $options, $depth);
126			}
127
128			/**
129			* Returns a closure that applies multiple $STRATEGIES to the value and returns the results
130			*
131			* > $compute = function ($value, $key) {
132			* > return 'some computation result';
133			* > };
134			* > $list = iter\iterable([new Data(1), new Data(2), new Data(3)]);
135			* > $list->map(select(['data' => null, 'id' => 'Identifier', 'desc' => 'Value.DescriptionName', 'comp' => $compute]));
136			* [
137			* [
138			* 'data' => Data(1),
139			* 'id' => Data(1)->Identifier,
140			* 'desc' => Data(1)->Value->DescriptionName,
141			* 'comp' => $compute(Data(1), 0),
142			* ],
143			* ...
144			* [
145			* 'data' => Data(3),
146			* 'id' => Data(3)->Identifier,
147			* 'desc' => Data(3)->Value->DescriptionName,
148			* 'comp' => $compute(Data(3), 2),
149			* ],
150			* ]
151			*
152			* @param array\|object $mappings
153			* @param null\|string\|\Closure $strategy
154			* @param boolean $discardNull
155			* @param boolean $discardEmptyContainer
156			* @return \Closure
157			* @deprecated Use \Zicht\Itertools\util\Mappings::select($mappings, $strategy, $discardNull, $discardEmptyContainer), will be removed in version 3.0
158			*/
159			function select($mappings, $strategy = null, $discardNull = false, $discardEmptyContainer = false)
160			{
161			return Mappings::select($mappings, $strategy, $discardNull, $discardEmptyContainer);
162			}
163
164			/**
165			* Returns a closure that returns random integer numbers between $MIN and $MAX
166			*
167			* @param int $min
168			* @param null\|int $max
169			* @return \Closure
170			* @deprecated Use \Zicht\Itertools\util\Mappings::random($min, $max), will be removed in version 3.0
171			*/
172			function random($min = 0, $max = null)
173			{
174			return Mappings::random($min, $max);
175			}
176
177			/**
178			* Returns a closure that returns either the class name, given an object, or otherwise the type
179			*
180			* @param null\|string\|\Closure $strategy
181			* @return \Closure
182			* @deprecated Use \Zicht\Itertools\util\Mappings::type($strategy), will be removed in version 3.0
183			*/
184			function type($strategy = null)
185			{
186			return Mappings::type($strategy);
187			}
188
189			/**
190			* Returns a closure that calls the mapping on each element once.
191			*
192			* > $compute = function ($value, $key) {
193			* > return 'some expensive computation result';
194			* > };
195			* > $list = iter\iterable([['id' => 42, ...], ['id' => 43, ...], ['id' => 42, ...]]);
196			* > $list->map(cache($compute, 'id'));
197			* [
198			* $compute(['id' => 42, ...]), // <-- calls the $compute method
199			* $compute(['id' => 43, ...]), // <-- calls the $compute method
200			* $compute(['id' => 42, ...]) // <-- does not call, instead, populates with cached values
201			* ]
202			*
203			* @param null\|string\|\Closure $mapping
204			* @param null\|string\|\Closure $strategy
205			* @return \Closure
206			* @deprecated Use \Zicht\Itertools\util\Mappings::cache($mapping, $strategy), will be removed in version 3.0
207			*/
208			function cache($mapping, $strategy = null)
209			{
210			return Mappings::cache($mapping, $strategy);
211			}
212
213			/**
214			* Returns a closure that returns the same value every time it is called.
215			*
216			* @param null\|string\|int\|float\|bool\|object\|array $value
217			* @return \Closure
218			* @deprecated Use \Zicht\Itertools\util\Mappings::constant($value), will be removed in version 3.0
219			*/
220			function constant($value)
221			{
222			return Mappings::constant($value);
223			}
224
225			/**
226			* Returns a mapping closure
227			*
228			* @param string $name
229			* @return \Closure
230			* @throws \InvalidArgumentException
231			* @deprecated please use the mapping functions directly, will be removed in version 3.0
232			*/
233			function get_mapping($name /* [argument, [arguments, ...] */)
234			{
235			if (is_string($name)) {
236			switch ($name) {
237			case 'ltrim':
238			case 'lstrip':
239			return call_user_func_array('\Zicht\Itertools\mappings\lstrip', array_slice(func_get_args(), 1));
240
241			case 'rtrim':
242			case 'rstrip':
243			return call_user_func_array('\Zicht\Itertools\mappings\rstrip', array_slice(func_get_args(), 1));
244
245			case 'trim':
246			case 'strip':
247			return call_user_func_array('\Zicht\Itertools\mappings\strip', array_slice(func_get_args(), 1));
248
249			case 'length':
250			return length();
251
252			case 'key':
253			return key();
254
255			case 'select':
256			return call_user_func_array('\Zicht\Itertools\mappings\select', array_slice(func_get_args(), 1));
257
258			case 'random':
259			return call_user_func_array('\Zicht\Itertools\mappings\random', array_slice(func_get_args(), 1));
260
261			case 'type':
262			return call_user_func_array('\Zicht\Itertools\mappings\type', array_slice(func_get_args(), 1));
263			}
264			}
265
266			throw new \InvalidArgumentException(sprintf('$NAME "%s" is not a valid mapping.', $name));
267			}
268
269			/**
270			* @param string $name
271			* @return \Closure
272			* @throws \InvalidArgumentException
273			* @deprecated please use the mapping functions directly, will be removed in version 3.0
274			*/
275			function getMapping($name /* [argument, [arguments, ...] */) // phpcs:ignore Zicht.NamingConventions.Functions.GlobalNaming
			0 ignored issues – show Unused Code introduced 2018-10-26 11:54 UTC by Report Bug Copy Issue Report The parameter `$name` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
276			{
277			return call_user_func_array('\Zicht\Itertools\mappings\get_mapping', func_get_args());
278			}
279

zicht / itertools

mappings.php ➔ get_mapping() C last analyzed 2021-03-29 13:12 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

mappings.php ➔ get_mapping() C
last analyzed 2021-03-29 13:12 UTC