ResponseCollection::seek() - Code Metrics - Inspection of "Added __debugInfo() to Message, Request, Response..." - pear2/Net_RouterOS - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( ead434...0a8e77 )

by Vasil

created 2018-10-04 16:28 UTC

ResponseCollection::seek() A

↳ Parent: ResponseCollection

Complexity

Conditions	4
Paths	8

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	7
nc	8
nop	1
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php

/**
 * ~~summary~~
 *
 * ~~description~~
 *
 * PHP version 5
 *
 * @category  Net
 * @package   PEAR2_Net_RouterOS
 * @author    Vasil Rangelov <[email protected]>
 * @copyright 2011 Vasil Rangelov
 * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
 * @version   GIT: $Id$
 * @link      http://pear2.php.net/PEAR2_Net_RouterOS
 */
/**
 * The namespace declaration.
 */
namespace PEAR2\Net\RouterOS;

/**
 * Implemented by this class.
 */
use ArrayAccess;

/**
 * Implemented by this class.
 */
use Countable;

/**
 * Implemented by this class.
 */
use SeekableIterator;

/**
 * Represents a collection of RouterOS responses.
 *
 * @category Net
 * @package  PEAR2_Net_RouterOS
 * @author   Vasil Rangelov <[email protected]>
 * @license  http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
 * @link     http://pear2.php.net/PEAR2_Net_RouterOS
 *
 * @method string getType()
 *     Calls {@link Response::getType()}
 *     on the response pointed by the pointer.
 * @method string[] getUnrecognizedWords()
 *     Calls {@link Response::getUnrecognizedWords()}
 *     on the response pointed by the pointer.
 * @method string|resource|null getProperty(string $name)
 *     Calls {@link Response::getProperty()}
 *     on the response pointed by the pointer.
 * @method string getTag()
 *     Calls {@link Response::getTag()}
 *     on the response pointed by the pointer.
 */
class ResponseCollection implements ArrayAccess, SeekableIterator, Countable
{

    /**
     * Used in {@link static::toArray()} as part of a bit mask.
     *
     * If set, it is effectively ignored. It is used merely as a placeholder.
     */
    const ARRAY_DEFAULT = 0;

    /**
     * Used in {@link static::toArray()} as part of a bit mask.
     *
     * If set, uses an index when available.
     * if not set, ignores it even if one was set with
     * {@link static::setIndex()}.
     */
    const ARRAY_INDEXED = 1;

    /**
     * Used in {@link static::toArray()} as part of a bit mask.
     *
     * If set, also serializes all {@link Response} objects to a plain array
     * using the __debugInfo() method.
     * If not set, the result will be an array of {@link Response} objects.
     */
    const ARRAY_RECURSIVE = 2;

    /**
     * An array with all {@link Response} objects.
     *
     * An array with all Response objects.
     *
     * @var Response[]
     */
    protected $responses = array();

    /**
     * An array with each Response object's type.
     *
     * An array with each {@link Response} object's type.
     *
     * @var string[]
     */
    protected $responseTypes = array();

    /**
     * An array with each Response object's tag.
     *
     * An array with each {@link Response} object's tag.
     *
     * @var string[]
     */
    protected $responseTags = array();

    /**
     * An array with positions of responses, based on an property name.
     *
     * The name of each property is the array key, and the array value
     * is another array where the key is the value for that property, and
     * the value is the position of the response. For performance reasons,
     * each key is built only when {@link static::setIndex()} is called with
     * that property, and remains available for the lifetime of this collection.
     *
     * @var array<string,array<string,int>>
     */
    protected $responsesIndex = array();

    /**
     * An array with all distinct properties.
     *
     * An array with all distinct properties across all {@link Response}
     * objects. Created at the first call of {@link static::getPropertyMap()}.
     *
     * @var array<string,int[]>
     */
    protected $propertyMap = null;

    /**
     * A pointer, as required by SeekableIterator.
     *
     * @var int
     */
    protected $position = 0;

    /**
     * Name of property to use as index
     *
     * NULL when disabled.
     *
     * @var string|null
     */
    protected $index = null;

    /**
     * Compare criteria.
     *
     * Used by {@link static::compare()} to determine the order between
     * two responses. See {@link static::orderBy()} for a detailed description
     * of this array's format.
     *
     * @var string[]|array<string,null|int|array<int|callable>>
     */
    protected $compareBy = array();

    /**
     * Creates a new collection.
     *
     * @param Response[] $responses An array of responses, in network order.
     */
    public function __construct(array $responses)
    {
        $pos = 0;
        foreach ($responses as $response) {
            if ($response instanceof Response) {
                $this->responseTypes[$pos] = $response->getType();
                $this->responseTags[$pos] = $response->getTag();
                $this->responses[$pos++] = $response;
            }
        }
    }

    /**
     * A shorthand gateway.
     *
     * This is a magic PHP method that allows you to call the object as a
     * function. Depending on the argument given, one of the other functions in
     * the class is invoked and its returned value is returned by this function.
     *
     * @param int|string|null $offset The offset of the response to seek to.
     *     If the offset is negative, seek to that relative to the end.
     *     If the collection is indexed, you can also supply a value to seek to.
     *     Setting NULL will get the current response's iterator.
     *
     * @return Response|\ArrayObject The {@link Response} at the specified
     *     offset, the current response's iterator (which is an ArrayObject)
     *     when NULL is given, or FALSE if the offset is invalid
     *     or the collection is empty.
     */
    public function __invoke($offset = null)
    {
        return null === $offset
            ? $this->current()->getIterator()
            : $this->seek($offset);
    }

    /**
     * Sets a property to be usable as a key in the collection.
     *
     * @param string|null $name The name of the property to use. Future calls
     *     that accept a position will then also be able to search values of
     *     that property for a matching value.
     *     Specifying NULL will disable such lookups (as is by default).
     *     Note that in case this value occurs multiple times within the
     *     collection, only the last matching response will be accessible by
     *     that value.
     *
     * @return $this The object itself.
     */
    public function setIndex($name)
    {
        if (null !== $name) {
            $name = (string)$name;
            if (!isset($this->responsesIndex[$name])) {
                $this->responsesIndex[$name] = array();
                foreach ($this->responses as $pos => $response) {
                    $val = $response->getProperty($name);
                    if (null !== $val) {
                        $this->responsesIndex[$name][$val] = $pos;
                    }
                }
            }
        }
        $this->index = $name;
        return $this;
    }

    /**
     * Gets the name of the property used as an index.
     *
     * @return string|null Name of property used as index. NULL when disabled.
     */
    public function getIndex()
    {
        return $this->index;
    }

    /**
     * Gets the whole collection as an array.
     *
     * @param int $flags A bit mask of this class' ARRAY_* constants.
     *
     * @return Response[] An array with all responses, in network order.
     */
    public function toArray($flags = self::ARRAY_DEFAULT)
    {
        $result = $this->responses;
        if (($flags & self::ARRAY_INDEXED) === self::ARRAY_INDEXED) {
            $positions = $this->responsesIndex[$this->index];
            asort($positions, SORT_NUMERIC);
            $positions = array_flip($positions);
            $result = array_combine(
                $positions,
                array_intersect_key($this->responses, $positions)
            );
        }
        if (($flags & self::ARRAY_RECURSIVE) === self::ARRAY_RECURSIVE) {
            foreach ($result as $key => $value) {
                $result[$key] = $value->__debugInfo();
            }
        }
        return $result;
    }

    /**
     * Get actionable debug info.
     *
     * This is a magic method available to PHP 5.6 and above, due to which
     * output of var_dump() will be more actionable.
     *
     * You can still call it in earlier versions to get the object as a plain array.
     *
     * @return array The info, as an associative array.
     */
    public function __debugInfo()
    {
        return $this->toArray(self::ARRAY_INDEXED | self::ARRAY_RECURSIVE);
    }

    /**
     * Counts the responses in the collection.
     *
     * @return int The number of responses in the collection.
     */
    public function count()
    {
        return count($this->responses);
    }

    /**
     * Checks if an offset exists.
     *
     * @param int|string $offset The offset to check. If the
     *     collection is indexed, you can also supply a value to check.
     *     Note that negative numeric offsets are NOT accepted.
     *
     * @return bool TRUE if the offset exists, FALSE otherwise.
     */
    public function offsetExists($offset)
    {
        return is_int($offset)
            ? array_key_exists($offset, $this->responses)
            : array_key_exists($offset, $this->responsesIndex[$this->index]);
    }

    /**
     * Gets a {@link Response} from a specified offset.
     *
     * @param int|string $offset The offset of the desired response. If the
     *     collection is indexed, you can also supply the value to search for.
     *
     * @return Response The response at the specified offset.
     */
    public function offsetGet($offset)
    {
        return is_int($offset)
            ? $this->responses[$offset >= 0
            ? $offset
            : count($this->responses) + $offset]
            : $this->responses[$this->responsesIndex[$this->index][$offset]];
    }

    /**
     * N/A
     *
     * This method exists only because it is required for ArrayAccess. The
     * collection is read only.
     *
     * @param int|string $offset N/A
     * @param Response   $value  N/A
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function offsetSet($offset, $value)
    {
    }

    /**
     * N/A
     *
     * This method exists only because it is required for ArrayAccess. The
     * collection is read only.
     *
     * @param int|string $offset N/A
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function offsetUnset($offset)
    {
    }

    /**
     * Resets the pointer to 0, and returns the first response.
     *
     * @return Response|false The first response in the collection,
     *     or FALSE if the collection is empty.
     */
    public function rewind()
    {
        return $this->seek(0);
    }

    /**
     * Moves the position pointer to a specified position.
     *
     * @param int|string $position The position to move to. If the collection is
     *     indexed, you can also supply a value to move the pointer to.
     *     A non-existent index will move the pointer to "-1".
     *
     * @return Response|false The {@link Response} at the specified position,
     *     or FALSE if the specified position is not valid.
     */
    public function seek($position)
    {
        $this->position = is_int($position)
            ? ($position >= 0
            ? $position
            : count($this->responses) + $position)
            : ($this->offsetExists($position)
            ? $this->responsesIndex[$this->index][$position]
            : -1);
        return $this->current();
    }

    /**
     * Moves the pointer forward by 1, and gets the next response.
     *
     * @return Response|false The next {@link Response} object,
     *     or FALSE if the position is not valid.
     */
    public function next()
    {
        ++$this->position;
        return $this->current();
    }

    /**
     * Gets the response at the current pointer position.
     *
     * @return Response|false The response at the current pointer position,
     *     or FALSE if the position is not valid.
     */
    public function current()
    {
        return $this->valid() ? $this->responses[$this->position] : false;
    }

    /**
     * Moves the pointer backwards by 1, and gets the previous response.
     *
     * @return Response|false The next {@link Response} object,
     *     or FALSE if the position is not valid.
     */
    public function prev()
    {
        --$this->position;
        return $this->current();
    }

    /**
     * Moves the pointer to the last valid position, and returns the last
     * response.
     *
     * @return Response|false The last response in the collection,
     *     or FALSE if the collection is empty.
     */
    public function end()
    {
        $this->position = count($this->responses) - 1;
        return $this->current();
    }

    /**
     * Gets the key at the current pointer position.
     *
     * @return int|false The key at the current pointer position,
     *     i.e. the pointer position itself, or FALSE if the position
     *     is not valid.
     */
    public function key()
    {
        return $this->valid() ? $this->position : false;
    }

    /**
     * Checks if the pointer is still pointing to an existing offset.
     *
     * @return bool TRUE if the pointer is valid, FALSE otherwise.
     */
    public function valid()
    {
        return $this->offsetExists($this->position);
    }

    /**
     * Gets all distinct property names.
     *
     * Gets all distinct property names across all responses.
     *
     * @return array<string,int[]> An array with
     *     all distinct property names as keys, and
     *     the indexes at which they occur as values.
     */
    public function getPropertyMap()
    {
        if (null === $this->propertyMap) {
            $properties = array();
            foreach ($this->responses as $index => $response) {
                $names = array_keys($response->getIterator()->getArrayCopy());
                foreach ($names as $name) {
                    if (!isset($properties[$name])) {
                        $properties[$name] = array();
                    }
                    $properties[$name][] = $index;
                }
            }
            $this->propertyMap = $properties;
        }
        return $this->propertyMap;
    }

    /**
     * Gets all responses of a specified type.
     *
     * @param string $type The response type to filter by. Valid values are the
     *     Response::TYPE_* constants.
     *
     * @return static A new collection with responses of the
     *     specified type.
     */
    public function getAllOfType($type)
    {
        $result = array();
        foreach (array_keys($this->responseTypes, $type, true) as $index) {
            $result[] = $this->responses[$index];
        }
        return new static($result);
    }

    /**
     * Gets all responses with a specified tag.
     *
     * @param string $tag The tag to filter by.
     *
     * @return static A new collection with responses having the
     *     specified tag.
     */
    public function getAllTagged($tag)
    {
        $result = array();
        foreach (array_keys($this->responseTags, $tag, true) as $index) {
            $result[] = $this->responses[$index];
        }
        return new static($result);
    }

    /**
     * Order resones by criteria.
     *
     * @param string[]|array<string,null|int|array<int|callable>> $criteria The
     *     criteria to order responses by. It takes the
     *     form of an array where each key is the name of the property to use
     *     as (N+1)th sorting key. The value of each member can be either NULL
     *     (for that property, sort normally in ascending order), a single sort
     *     order constant (SORT_ASC or SORT_DESC) to sort normally in the
     *     specified order, an array where the first member is an order
     *     constant, and the second one is sorting flags (same as built in PHP
     *     array functions) or a callback.
     *     If a callback is provided, it must accept two arguments
     *     (the two values to be compared), and return -1, 0 or 1 if the first
     *     value is respectively less than, equal to or greater than the second
     *     one.
     *     Each key of $criteria can also be numeric, in which case the
     *     value is the name of the property, and sorting is done normally in
     *     ascending order.
     *
     * @return static A new collection with the responses sorted in the
     *     specified order.
     */
    public function orderBy(array $criteria)
    {
        $this->compareBy = $criteria;
        $sortedResponses = $this->responses;
        usort($sortedResponses, array($this, 'compare'));
        return new static($sortedResponses);
    }

    /**
     * Calls a method of the response pointed by the pointer.
     *
     * Calls a method of the response pointed by the pointer. This is a magic
     * PHP method, thanks to which any function you call on the collection that
     * is not defined will be redirected to the response.
     *
     * @param string $method The name of the method to call.
     * @param array  $args   The arguments to pass to the method.
     *
     * @return mixed Whatever the called function returns.
     */
    public function __call($method, array $args)
    {
        return call_user_func_array(
            array($this->current(), $method),
            $args
        );
    }

    /**
     * Compares two responses.
     *
     * Compares two responses, based on criteria defined in
     * {@link static::$compareBy}.
     *
     * @param Response $itemA The response to compare.
     * @param Response $itemB The response to compare $a against.
     *
     * @return int Returns 0 if the two responses are equal according to every
     *     criteria specified, -1 if $a should be placed before $b, and 1 if $b
     *     should be placed before $a.
     */
    protected function compare(Response $itemA, Response $itemB)
    {
        foreach ($this->compareBy as $name => $spec) {
            if (!is_string($name)) {
                $name = $spec;
                $spec = null;
            }

            $members = array(
                0 => $itemA->getProperty($name),
                1 => $itemB->getProperty($name)
            );

            if (is_callable($spec)) {
                uasort($members, $spec);
            } elseif ($members[0] === $members[1]) {
                continue;
            } else {
                $flags = SORT_REGULAR;
                $order = SORT_ASC;
                if (is_array($spec)) {
                    list($order, $flags) = $spec;
                } elseif (null !== $spec) {
                    $order = $spec;
                }

                if (SORT_ASC === $order) {
                    asort($members, $flags);
                } else {
                    arsort($members, $flags);
                }
            }
            return (key($members) === 0) ? -1 : 1;
        }

        return 0;
    }
}


1			<?php
2
3			/**
4			* ~~summary~~
5			*
6			* ~~description~~
7			*
8			* PHP version 5
9			*
10			* @category Net
11			* @package PEAR2_Net_RouterOS
12			* @author Vasil Rangelov <[email protected]>
13			* @copyright 2011 Vasil Rangelov
14			* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
15			* @version GIT: $Id$
16			* @link http://pear2.php.net/PEAR2_Net_RouterOS
17			*/
18			/**
19			* The namespace declaration.
20			*/
21			namespace PEAR2\Net\RouterOS;
22
23			/**
24			* Implemented by this class.
25			*/
26			use ArrayAccess;
27
28			/**
29			* Implemented by this class.
30			*/
31			use Countable;
32
33			/**
34			* Implemented by this class.
35			*/
36			use SeekableIterator;
37
38			/**
39			* Represents a collection of RouterOS responses.
40			*
41			* @category Net
42			* @package PEAR2_Net_RouterOS
43			* @author Vasil Rangelov <[email protected]>
44			* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
45			* @link http://pear2.php.net/PEAR2_Net_RouterOS
46			*
47			* @method string getType()
48			* Calls {@link Response::getType()}
49			* on the response pointed by the pointer.
50			* @method string[] getUnrecognizedWords()
51			* Calls {@link Response::getUnrecognizedWords()}
52			* on the response pointed by the pointer.
53			* @method string\|resource\|null getProperty(string $name)
54			* Calls {@link Response::getProperty()}
55			* on the response pointed by the pointer.
56			* @method string getTag()
57			* Calls {@link Response::getTag()}
58			* on the response pointed by the pointer.
59			*/
60			class ResponseCollection implements ArrayAccess, SeekableIterator, Countable
61			{
62
63			/**
64			* Used in {@link static::toArray()} as part of a bit mask.
65			*
66			* If set, it is effectively ignored. It is used merely as a placeholder.
67			*/
68			const ARRAY_DEFAULT = 0;
69
70			/**
71			* Used in {@link static::toArray()} as part of a bit mask.
72			*
73			* If set, uses an index when available.
74			* if not set, ignores it even if one was set with
75			* {@link static::setIndex()}.
76			*/
77			const ARRAY_INDEXED = 1;
78
79			/**
80			* Used in {@link static::toArray()} as part of a bit mask.
81			*
82			* If set, also serializes all {@link Response} objects to a plain array
83			* using the __debugInfo() method.
84			* If not set, the result will be an array of {@link Response} objects.
85			*/
86			const ARRAY_RECURSIVE = 2;
87
88			/**
89			* An array with all {@link Response} objects.
90			*
91			* An array with all Response objects.
92			*
93			* @var Response[]
94			*/
95			protected $responses = array();
96
97			/**
98			* An array with each Response object's type.
99			*
100			* An array with each {@link Response} object's type.
101			*
102			* @var string[]
103			*/
104			protected $responseTypes = array();
105
106			/**
107			* An array with each Response object's tag.
108			*
109			* An array with each {@link Response} object's tag.
110			*
111			* @var string[]
112			*/
113			protected $responseTags = array();
114
115			/**
116			* An array with positions of responses, based on an property name.
117			*
118			* The name of each property is the array key, and the array value
119			* is another array where the key is the value for that property, and
120			* the value is the position of the response. For performance reasons,
121			* each key is built only when {@link static::setIndex()} is called with
122			* that property, and remains available for the lifetime of this collection.
123			*
124			* @var array<string,array<string,int>>
125			*/
126			protected $responsesIndex = array();
127
128			/**
129			* An array with all distinct properties.
130			*
131			* An array with all distinct properties across all {@link Response}
132			* objects. Created at the first call of {@link static::getPropertyMap()}.
133			*
134			* @var array<string,int[]>
135			*/
136			protected $propertyMap = null;
137
138			/**
139			* A pointer, as required by SeekableIterator.
140			*
141			* @var int
142			*/
143			protected $position = 0;
144
145			/**
146			* Name of property to use as index
147			*
148			* NULL when disabled.
149			*
150			* @var string\|null
151			*/
152			protected $index = null;
153
154			/**
155			* Compare criteria.
156			*
157			* Used by {@link static::compare()} to determine the order between
158			* two responses. See {@link static::orderBy()} for a detailed description
159			* of this array's format.
160			*
161			* @var string[]\|array<string,null\|int\|array<int\|callable>>
162			*/
163			protected $compareBy = array();
164
165			/**
166			* Creates a new collection.
167			*
168			* @param Response[] $responses An array of responses, in network order.
169			*/
170			public function __construct(array $responses)
171			{
172			$pos = 0;
173			foreach ($responses as $response) {
174			if ($response instanceof Response) {
175			$this->responseTypes[$pos] = $response->getType();
176			$this->responseTags[$pos] = $response->getTag();
177			$this->responses[$pos++] = $response;
178			}
179			}
180			}
181
182			/**
183			* A shorthand gateway.
184			*
185			* This is a magic PHP method that allows you to call the object as a
186			* function. Depending on the argument given, one of the other functions in
187			* the class is invoked and its returned value is returned by this function.
188			*
189			* @param int\|string\|null $offset The offset of the response to seek to.
190			* If the offset is negative, seek to that relative to the end.
191			* If the collection is indexed, you can also supply a value to seek to.
192			* Setting NULL will get the current response's iterator.
193			*
194			* @return Response\|\ArrayObject The {@link Response} at the specified
195			* offset, the current response's iterator (which is an ArrayObject)
196			* when NULL is given, or FALSE if the offset is invalid
197			* or the collection is empty.
198			*/
199			public function __invoke($offset = null)
200			{
201			return null === $offset
202			? $this->current()->getIterator()
203			: $this->seek($offset);
204			}
205
206			/**
207			* Sets a property to be usable as a key in the collection.
208			*
209			* @param string\|null $name The name of the property to use. Future calls
210			* that accept a position will then also be able to search values of
211			* that property for a matching value.
212			* Specifying NULL will disable such lookups (as is by default).
213			* Note that in case this value occurs multiple times within the
214			* collection, only the last matching response will be accessible by
215			* that value.
216			*
217			* @return $this The object itself.
218			*/
219			public function setIndex($name)
220			{
221			if (null !== $name) {
222			$name = (string)$name;
223			if (!isset($this->responsesIndex[$name])) {
224			$this->responsesIndex[$name] = array();
225			foreach ($this->responses as $pos => $response) {
226			$val = $response->getProperty($name);
227			if (null !== $val) {
228			$this->responsesIndex[$name][$val] = $pos;
229			}
230			}
231			}
232			}
233			$this->index = $name;
234			return $this;
235			}
236
237			/**
238			* Gets the name of the property used as an index.
239			*
240			* @return string\|null Name of property used as index. NULL when disabled.
241			*/
242			public function getIndex()
243			{
244			return $this->index;
245			}
246
247			/**
248			* Gets the whole collection as an array.
249			*
250			* @param int $flags A bit mask of this class' ARRAY_* constants.
251			*
252			* @return Response[] An array with all responses, in network order.
253			*/
254			public function toArray($flags = self::ARRAY_DEFAULT)
255			{
256			$result = $this->responses;
257			if (($flags & self::ARRAY_INDEXED) === self::ARRAY_INDEXED) {
258			$positions = $this->responsesIndex[$this->index];
259			asort($positions, SORT_NUMERIC);
260			$positions = array_flip($positions);
261			$result = array_combine(
262			$positions,
263			array_intersect_key($this->responses, $positions)
264			);
265			}
266			if (($flags & self::ARRAY_RECURSIVE) === self::ARRAY_RECURSIVE) {
267			foreach ($result as $key => $value) {
268			$result[$key] = $value->__debugInfo();
269			}
270			}
271			return $result;
272			}
273
274			/**
275			* Get actionable debug info.
276			*
277			* This is a magic method available to PHP 5.6 and above, due to which
278			* output of var_dump() will be more actionable.
279			*
280			* You can still call it in earlier versions to get the object as a plain array.
281			*
282			* @return array The info, as an associative array.
283			*/
284			public function __debugInfo()
285			{
286			return $this->toArray(self::ARRAY_INDEXED \| self::ARRAY_RECURSIVE);
287			}
288
289			/**
290			* Counts the responses in the collection.
291			*
292			* @return int The number of responses in the collection.
293			*/
294			public function count()
295			{
296			return count($this->responses);
297			}
298
299			/**
300			* Checks if an offset exists.
301			*
302			* @param int\|string $offset The offset to check. If the
303			* collection is indexed, you can also supply a value to check.
304			* Note that negative numeric offsets are NOT accepted.
305			*
306			* @return bool TRUE if the offset exists, FALSE otherwise.
307			*/
308			public function offsetExists($offset)
309			{
310			return is_int($offset)
311			? array_key_exists($offset, $this->responses)
312			: array_key_exists($offset, $this->responsesIndex[$this->index]);
313			}
314
315			/**
316			* Gets a {@link Response} from a specified offset.
317			*
318			* @param int\|string $offset The offset of the desired response. If the
319			* collection is indexed, you can also supply the value to search for.
320			*
321			* @return Response The response at the specified offset.
322			*/
323			public function offsetGet($offset)
324			{
325			return is_int($offset)
326			? $this->responses[$offset >= 0
327			? $offset
328			: count($this->responses) + $offset]
329			: $this->responses[$this->responsesIndex[$this->index][$offset]];
330			}
331
332			/**
333			* N/A
334			*
335			* This method exists only because it is required for ArrayAccess. The
336			* collection is read only.
337			*
338			* @param int\|string $offset N/A
339			* @param Response $value N/A
340			*
341			* @return void
342			*
343			* @SuppressWarnings(PHPMD.UnusedFormalParameter)
344			*/
345			public function offsetSet($offset, $value)
346			{
347			}
348
349			/**
350			* N/A
351			*
352			* This method exists only because it is required for ArrayAccess. The
353			* collection is read only.
354			*
355			* @param int\|string $offset N/A
356			*
357			* @return void
358			*
359			* @SuppressWarnings(PHPMD.UnusedFormalParameter)
360			*/
361			public function offsetUnset($offset)
362			{
363			}
364
365			/**
366			* Resets the pointer to 0, and returns the first response.
367			*
368			* @return Response\|false The first response in the collection,
369			* or FALSE if the collection is empty.
370			*/
371			public function rewind()
372			{
373			return $this->seek(0);
374			}
375
376			/**
377			* Moves the position pointer to a specified position.
378			*
379			* @param int\|string $position The position to move to. If the collection is
380			* indexed, you can also supply a value to move the pointer to.
381			* A non-existent index will move the pointer to "-1".
382			*
383			* @return Response\|false The {@link Response} at the specified position,
384			* or FALSE if the specified position is not valid.
385			*/
386			public function seek($position)
387			{
388			$this->position = is_int($position)
389			? ($position >= 0
390			? $position
391			: count($this->responses) + $position)
392			: ($this->offsetExists($position)
393			? $this->responsesIndex[$this->index][$position]
394			: -1);
395			return $this->current();
396			}
397
398			/**
399			* Moves the pointer forward by 1, and gets the next response.
400			*
401			* @return Response\|false The next {@link Response} object,
402			* or FALSE if the position is not valid.
403			*/
404			public function next()
405			{
406			++$this->position;
407			return $this->current();
408			}
409
410			/**
411			* Gets the response at the current pointer position.
412			*
413			* @return Response\|false The response at the current pointer position,
414			* or FALSE if the position is not valid.
415			*/
416			public function current()
417			{
418			return $this->valid() ? $this->responses[$this->position] : false;
419			}
420
421			/**
422			* Moves the pointer backwards by 1, and gets the previous response.
423			*
424			* @return Response\|false The next {@link Response} object,
425			* or FALSE if the position is not valid.
426			*/
427			public function prev()
428			{
429			--$this->position;
430			return $this->current();
431			}
432
433			/**
434			* Moves the pointer to the last valid position, and returns the last
435			* response.
436			*
437			* @return Response\|false The last response in the collection,
438			* or FALSE if the collection is empty.
439			*/
440			public function end()
441			{
442			$this->position = count($this->responses) - 1;
443			return $this->current();
444			}
445
446			/**
447			* Gets the key at the current pointer position.
448			*
449			* @return int\|false The key at the current pointer position,
450			* i.e. the pointer position itself, or FALSE if the position
451			* is not valid.
452			*/
453			public function key()
454			{
455			return $this->valid() ? $this->position : false;
456			}
457
458			/**
459			* Checks if the pointer is still pointing to an existing offset.
460			*
461			* @return bool TRUE if the pointer is valid, FALSE otherwise.
462			*/
463			public function valid()
464			{
465			return $this->offsetExists($this->position);
466			}
467
468			/**
469			* Gets all distinct property names.
470			*
471			* Gets all distinct property names across all responses.
472			*
473			* @return array<string,int[]> An array with
474			* all distinct property names as keys, and
475			* the indexes at which they occur as values.
476			*/
477			public function getPropertyMap()
478			{
479			if (null === $this->propertyMap) {
480			$properties = array();
481			foreach ($this->responses as $index => $response) {
482			$names = array_keys($response->getIterator()->getArrayCopy());
483			foreach ($names as $name) {
484			if (!isset($properties[$name])) {
485			$properties[$name] = array();
486			}
487			$properties[$name][] = $index;
488			}
489			}
490			$this->propertyMap = $properties;
491			}
492			return $this->propertyMap;
493			}
494
495			/**
496			* Gets all responses of a specified type.
497			*
498			* @param string $type The response type to filter by. Valid values are the
499			* Response::TYPE_* constants.
500			*
501			* @return static A new collection with responses of the
502			* specified type.
503			*/
504			public function getAllOfType($type)
505			{
506			$result = array();
507			foreach (array_keys($this->responseTypes, $type, true) as $index) {
508			$result[] = $this->responses[$index];
509			}
510			return new static($result);
511			}
512
513			/**
514			* Gets all responses with a specified tag.
515			*
516			* @param string $tag The tag to filter by.
517			*
518			* @return static A new collection with responses having the
519			* specified tag.
520			*/
521			public function getAllTagged($tag)
522			{
523			$result = array();
524			foreach (array_keys($this->responseTags, $tag, true) as $index) {
525			$result[] = $this->responses[$index];
526			}
527			return new static($result);
528			}
529
530			/**
531			* Order resones by criteria.
532			*
533			* @param string[]\|array<string,null\|int\|array<int\|callable>> $criteria The
534			* criteria to order responses by. It takes the
535			* form of an array where each key is the name of the property to use
536			* as (N+1)th sorting key. The value of each member can be either NULL
537			* (for that property, sort normally in ascending order), a single sort
538			* order constant (SORT_ASC or SORT_DESC) to sort normally in the
539			* specified order, an array where the first member is an order
540			* constant, and the second one is sorting flags (same as built in PHP
541			* array functions) or a callback.
542			* If a callback is provided, it must accept two arguments
543			* (the two values to be compared), and return -1, 0 or 1 if the first
544			* value is respectively less than, equal to or greater than the second
545			* one.
546			* Each key of $criteria can also be numeric, in which case the
547			* value is the name of the property, and sorting is done normally in
548			* ascending order.
549			*
550			* @return static A new collection with the responses sorted in the
551			* specified order.
552			*/
553			public function orderBy(array $criteria)
554			{
555			$this->compareBy = $criteria;
556			$sortedResponses = $this->responses;
557			usort($sortedResponses, array($this, 'compare'));
558			return new static($sortedResponses);
559			}
560
561			/**
562			* Calls a method of the response pointed by the pointer.
563			*
564			* Calls a method of the response pointed by the pointer. This is a magic
565			* PHP method, thanks to which any function you call on the collection that
566			* is not defined will be redirected to the response.
567			*
568			* @param string $method The name of the method to call.
569			* @param array $args The arguments to pass to the method.
570			*
571			* @return mixed Whatever the called function returns.
572			*/
573			public function __call($method, array $args)
574			{
575			return call_user_func_array(
576			array($this->current(), $method),
577			$args
578			);
579			}
580
581			/**
582			* Compares two responses.
583			*
584			* Compares two responses, based on criteria defined in
585			* {@link static::$compareBy}.
586			*
587			* @param Response $itemA The response to compare.
588			* @param Response $itemB The response to compare $a against.
589			*
590			* @return int Returns 0 if the two responses are equal according to every
591			* criteria specified, -1 if $a should be placed before $b, and 1 if $b
592			* should be placed before $a.
593			*/
594			protected function compare(Response $itemA, Response $itemB)
595			{
596			foreach ($this->compareBy as $name => $spec) {
597			if (!is_string($name)) {
598			$name = $spec;
599			$spec = null;
600			}
601
602			$members = array(
603			0 => $itemA->getProperty($name),
604			1 => $itemB->getProperty($name)
605			);
606
607			if (is_callable($spec)) {
608			uasort($members, $spec);
609			} elseif ($members[0] === $members[1]) {
610			continue;
611			} else {
612			$flags = SORT_REGULAR;
613			$order = SORT_ASC;
614			if (is_array($spec)) {
615			list($order, $flags) = $spec;
616			} elseif (null !== $spec) {
617			$order = $spec;
618			}
619
620			if (SORT_ASC === $order) {
621			asort($members, $flags);
622			} else {
623			arsort($members, $flags);
624			}
625			}
626			return (key($members) === 0) ? -1 : 1;
627			}
628
629			return 0;
630			}
631			}
632

pear2 / Net_RouterOS

Push — develop ( ead434...0a8e77 )

ResponseCollection::seek() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like