mirror of
https://github.com/OpenXE-org/OpenXE.git
synced 2025-01-01 01:20:29 +01:00
434 lines
9.4 KiB
PHP
434 lines
9.4 KiB
PHP
<?php
|
|
|
|
/**
|
|
* @see https://github.com/laminas/laminas-stdlib for the canonical source repository
|
|
* @copyright https://github.com/laminas/laminas-stdlib/blob/master/COPYRIGHT.md
|
|
* @license https://github.com/laminas/laminas-stdlib/blob/master/LICENSE.md New BSD License
|
|
*/
|
|
|
|
namespace Laminas\Stdlib;
|
|
|
|
use ArrayAccess;
|
|
use Countable;
|
|
use IteratorAggregate;
|
|
use Serializable;
|
|
|
|
/**
|
|
* Custom framework ArrayObject implementation
|
|
*
|
|
* Extends version-specific "abstract" implementation.
|
|
*/
|
|
class ArrayObject implements IteratorAggregate, ArrayAccess, Serializable, Countable
|
|
{
|
|
/**
|
|
* Properties of the object have their normal functionality
|
|
* when accessed as list (var_dump, foreach, etc.).
|
|
*/
|
|
const STD_PROP_LIST = 1;
|
|
|
|
/**
|
|
* Entries can be accessed as properties (read and write).
|
|
*/
|
|
const ARRAY_AS_PROPS = 2;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $storage;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $flag;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
protected $iteratorClass;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $protectedProperties;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @param array $input
|
|
* @param int $flags
|
|
* @param string $iteratorClass
|
|
*/
|
|
public function __construct($input = [], $flags = self::STD_PROP_LIST, $iteratorClass = 'ArrayIterator')
|
|
{
|
|
$this->setFlags($flags);
|
|
$this->storage = $input;
|
|
$this->setIteratorClass($iteratorClass);
|
|
$this->protectedProperties = array_keys(get_object_vars($this));
|
|
}
|
|
|
|
/**
|
|
* Returns whether the requested key exists
|
|
*
|
|
* @param mixed $key
|
|
* @return bool
|
|
*/
|
|
public function __isset($key)
|
|
{
|
|
if ($this->flag == self::ARRAY_AS_PROPS) {
|
|
return $this->offsetExists($key);
|
|
}
|
|
if (in_array($key, $this->protectedProperties)) {
|
|
throw new Exception\InvalidArgumentException('$key is a protected property, use a different key');
|
|
}
|
|
|
|
return isset($this->$key);
|
|
}
|
|
|
|
/**
|
|
* Sets the value at the specified key to value
|
|
*
|
|
* @param mixed $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function __set($key, $value)
|
|
{
|
|
if ($this->flag == self::ARRAY_AS_PROPS) {
|
|
return $this->offsetSet($key, $value);
|
|
}
|
|
if (in_array($key, $this->protectedProperties)) {
|
|
throw new Exception\InvalidArgumentException('$key is a protected property, use a different key');
|
|
}
|
|
$this->$key = $value;
|
|
}
|
|
|
|
/**
|
|
* Unsets the value at the specified key
|
|
*
|
|
* @param mixed $key
|
|
* @return void
|
|
*/
|
|
public function __unset($key)
|
|
{
|
|
if ($this->flag == self::ARRAY_AS_PROPS) {
|
|
return $this->offsetUnset($key);
|
|
}
|
|
if (in_array($key, $this->protectedProperties)) {
|
|
throw new Exception\InvalidArgumentException('$key is a protected property, use a different key');
|
|
}
|
|
unset($this->$key);
|
|
}
|
|
|
|
/**
|
|
* Returns the value at the specified key by reference
|
|
*
|
|
* @param mixed $key
|
|
* @return mixed
|
|
*/
|
|
public function &__get($key)
|
|
{
|
|
$ret = null;
|
|
if ($this->flag == self::ARRAY_AS_PROPS) {
|
|
$ret =& $this->offsetGet($key);
|
|
|
|
return $ret;
|
|
}
|
|
if (in_array($key, $this->protectedProperties)) {
|
|
throw new Exception\InvalidArgumentException('$key is a protected property, use a different key');
|
|
}
|
|
|
|
return $this->$key;
|
|
}
|
|
|
|
/**
|
|
* Appends the value
|
|
*
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function append($value)
|
|
{
|
|
$this->storage[] = $value;
|
|
}
|
|
|
|
/**
|
|
* Sort the entries by value
|
|
*
|
|
* @return void
|
|
*/
|
|
public function asort()
|
|
{
|
|
asort($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Get the number of public properties in the ArrayObject
|
|
*
|
|
* @return int
|
|
*/
|
|
public function count()
|
|
{
|
|
return count($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Exchange the array for another one.
|
|
*
|
|
* @param array|ArrayObject $data
|
|
* @return array
|
|
*/
|
|
public function exchangeArray($data)
|
|
{
|
|
if (! is_array($data) && ! is_object($data)) {
|
|
throw new Exception\InvalidArgumentException(
|
|
'Passed variable is not an array or object, using empty array instead'
|
|
);
|
|
}
|
|
|
|
if (is_object($data) && ($data instanceof self || $data instanceof \ArrayObject)) {
|
|
$data = $data->getArrayCopy();
|
|
}
|
|
if (! is_array($data)) {
|
|
$data = (array) $data;
|
|
}
|
|
|
|
$storage = $this->storage;
|
|
|
|
$this->storage = $data;
|
|
|
|
return $storage;
|
|
}
|
|
|
|
/**
|
|
* Creates a copy of the ArrayObject.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getArrayCopy()
|
|
{
|
|
return $this->storage;
|
|
}
|
|
|
|
/**
|
|
* Gets the behavior flags.
|
|
*
|
|
* @return int
|
|
*/
|
|
public function getFlags()
|
|
{
|
|
return $this->flag;
|
|
}
|
|
|
|
/**
|
|
* Create a new iterator from an ArrayObject instance
|
|
*
|
|
* @return \Iterator
|
|
*/
|
|
public function getIterator()
|
|
{
|
|
$class = $this->iteratorClass;
|
|
|
|
return new $class($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Gets the iterator classname for the ArrayObject.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getIteratorClass()
|
|
{
|
|
return $this->iteratorClass;
|
|
}
|
|
|
|
/**
|
|
* Sort the entries by key
|
|
*
|
|
* @return void
|
|
*/
|
|
public function ksort()
|
|
{
|
|
ksort($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Sort an array using a case insensitive "natural order" algorithm
|
|
*
|
|
* @return void
|
|
*/
|
|
public function natcasesort()
|
|
{
|
|
natcasesort($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Sort entries using a "natural order" algorithm
|
|
*
|
|
* @return void
|
|
*/
|
|
public function natsort()
|
|
{
|
|
natsort($this->storage);
|
|
}
|
|
|
|
/**
|
|
* Returns whether the requested key exists
|
|
*
|
|
* @param mixed $key
|
|
* @return bool
|
|
*/
|
|
public function offsetExists($key)
|
|
{
|
|
return isset($this->storage[$key]);
|
|
}
|
|
|
|
/**
|
|
* Returns the value at the specified key
|
|
*
|
|
* @param mixed $key
|
|
* @return mixed
|
|
*/
|
|
public function &offsetGet($key)
|
|
{
|
|
$ret = null;
|
|
if (! $this->offsetExists($key)) {
|
|
return $ret;
|
|
}
|
|
$ret =& $this->storage[$key];
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Sets the value at the specified key to value
|
|
*
|
|
* @param mixed $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function offsetSet($key, $value)
|
|
{
|
|
$this->storage[$key] = $value;
|
|
}
|
|
|
|
/**
|
|
* Unsets the value at the specified key
|
|
*
|
|
* @param mixed $key
|
|
* @return void
|
|
*/
|
|
public function offsetUnset($key)
|
|
{
|
|
if ($this->offsetExists($key)) {
|
|
unset($this->storage[$key]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Serialize an ArrayObject
|
|
*
|
|
* @return string
|
|
*/
|
|
public function serialize()
|
|
{
|
|
return serialize(get_object_vars($this));
|
|
}
|
|
|
|
/**
|
|
* Sets the behavior flags
|
|
*
|
|
* @param int $flags
|
|
* @return void
|
|
*/
|
|
public function setFlags($flags)
|
|
{
|
|
$this->flag = $flags;
|
|
}
|
|
|
|
/**
|
|
* Sets the iterator classname for the ArrayObject
|
|
*
|
|
* @param string $class
|
|
* @return void
|
|
*/
|
|
public function setIteratorClass($class)
|
|
{
|
|
if (class_exists($class)) {
|
|
$this->iteratorClass = $class;
|
|
|
|
return ;
|
|
}
|
|
|
|
if (strpos($class, '\\') === 0) {
|
|
$class = '\\' . $class;
|
|
if (class_exists($class)) {
|
|
$this->iteratorClass = $class;
|
|
|
|
return ;
|
|
}
|
|
}
|
|
|
|
throw new Exception\InvalidArgumentException('The iterator class does not exist');
|
|
}
|
|
|
|
/**
|
|
* Sort the entries with a user-defined comparison function and maintain key association
|
|
*
|
|
* @param callable $function
|
|
* @return void
|
|
*/
|
|
public function uasort($function)
|
|
{
|
|
if (is_callable($function)) {
|
|
uasort($this->storage, $function);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sort the entries by keys using a user-defined comparison function
|
|
*
|
|
* @param callable $function
|
|
* @return void
|
|
*/
|
|
public function uksort($function)
|
|
{
|
|
if (is_callable($function)) {
|
|
uksort($this->storage, $function);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unserialize an ArrayObject
|
|
*
|
|
* @param string $data
|
|
* @return void
|
|
*/
|
|
public function unserialize($data)
|
|
{
|
|
$ar = unserialize($data);
|
|
$this->protectedProperties = array_keys(get_object_vars($this));
|
|
|
|
$this->setFlags($ar['flag']);
|
|
$this->exchangeArray($ar['storage']);
|
|
$this->setIteratorClass($ar['iteratorClass']);
|
|
|
|
foreach ($ar as $k => $v) {
|
|
switch ($k) {
|
|
case 'flag':
|
|
$this->setFlags($v);
|
|
break;
|
|
case 'storage':
|
|
$this->exchangeArray($v);
|
|
break;
|
|
case 'iteratorClass':
|
|
$this->setIteratorClass($v);
|
|
break;
|
|
case 'protectedProperties':
|
|
break;
|
|
default:
|
|
$this->__set($k, $v);
|
|
}
|
|
}
|
|
}
|
|
}
|