src/Dreamscape/ResellerApiSdk/DataObject/Collection.php line 246

  1. <?php
  3. namespace App\Dreamscape\ResellerApiSdk\DataObject;
  5. use App\Dreamscape\ResellerApiSdk\DataObject\Structure\DataType;
  6. use InvalidArgumentException;
  7. use Iterator;
  8. use ArrayAccess;
  9. use Countable;
  11. /**
  12.  * Class for storing the collection of data-objects and primitives.
  13.  *
  14.  * @property-read string $type
  15.  * @property-read int $totalItems
  16.  * @property-read int $totalPages
  17.  * @property-read int $currentPage
  18.  *
  19.  * @copyright Dreamscape Networks International Pte Ltd https://www.dreamscapenetworks.com
  20.  */
  21. final class Collection implements Iterator, ArrayAccess, Countable
  22. {
  23.     private array $items = [];
  24.     private string $type;
  25.     private bool $is_type_primitive = false;
  27.     private int $total_items = 0;
  28.     private int $total_pages = 1;
  29.     private int $current_page = 1;
  31.     /**
  32.      * Constructor.
  33.      *
  34.      * @param string $type
  35.      *
  36.      * @throws InvalidArgumentException
  37.      */
  38.     private function __construct(string $type)
  39.     {
  40.         if (empty($type)) {
  41.             throw new InvalidArgumentException('The argument $type must be not empty string');
  42.         }
  44.         if (DataType::isValid($type)) {
  45.             $this->is_type_primitive = true;
  46.         } elseif (!in_array(AbstractDataObject::class, class_parents($type))) {
  47.             throw new InvalidArgumentException('The class must be heir of \'' . AbstractDataObject::class . '\'');
  48.         }
  50.         $this->type = $type;
  51.     }
  53.     /**
  54.      * Created the instance of collection of the specified type.
  55.      *
  56.      * @param string $type
  57.      * @param int $total_items
  58.      * @param int $total_pages
  59.      * @param int $current_page
  60.      *
  61.      * @return self
  62.      *
  63.      * @throws InvalidArgumentException
  64.      */
  65.     public static function build(
  66.         string $type,
  67.         int $total_items = 0,
  68.         int $total_pages = 1,
  69.         int $current_page = 1
  70.     ): self {
  71.         $object = new self($type);
  72.         $object->total_items = $total_items;
  73.         $object->total_pages = $total_pages;
  74.         $object->current_page = $current_page;
  76.         return $object;
  77.     }
  79.     /**
  80.      * @param string $name
  81.      *
  82.      * @return string
  83.      *
  84.      * @throws InvalidArgumentException
  85.      */
  86.     public function __get(string $name)
  87.     {
  88.         if (empty($name)) {
  89.             throw new InvalidArgumentException('The argument $name must be not empty string');
  90.         }
  92.         switch ($name) {
  93.             case 'type':
  94.                 return $this->type;
  96.             case 'totalItems':
  97.                 return $this->total_items;
  99.             case 'totalPages':
  100.                 return $this->total_pages;
  102.             case 'currentPage':
  103.                 return $this->current_page;
  104.         }
  106.         throw new InvalidArgumentException('The property \'' . $name . '\' does not exist');
  107.     }
  109.     /**
  110.      * @param array $items
  111.      *
  112.      * @return self
  113.      *
  114.      * @throws InvalidArgumentException
  115.      */
  116.     public function import(array $items): self
  117.     {
  118.         foreach ($items as $item) {
  119.             $this->add($item);
  120.         }
  122.         return $this;
  123.     }
  125.     /**
  126.      * @param mixed $item
  127.      *
  128.      * @return self
  129.      *
  130.      * @throws InvalidArgumentException
  131.      */
  132.     public function add($item): self
  133.     {
  134.         $this->checkItemApplicable($item);
  136.         $this->items[] = $this->is_type_primitive ? DataType::convert($this->type, $item) : $item;
  138.         return $this;
  139.     }
  141.     /**
  142.      * Checks is the provided item applicable for this collection
  143.      * according to its type.
  144.      *
  145.      * @param mixed $item
  146.      *
  147.      * @throws InvalidArgumentException
  148.      */
  149.     private function checkItemApplicable($item)
  150.     {
  151.         if ($this->is_type_primitive) {
  152.             if (!DataType::isValueApplicable($this->type, $item)) {
  153.                 throw new InvalidArgumentException(
  154.                     'Only items of type \'' . $this->type . '\' can be ' .
  155.                     'added, \'' . DataType::getType($item) . '\' provided'
  156.                 );
  157.             }
  158.         } elseif (!$item instanceof $this->type) {
  159.             throw new InvalidArgumentException(
  160.                 'Only instances of \'' . $this->type . '\' class ' .
  161.                 'can be added, \'' . DataType::getType($item) . '\' provided'
  162.             );
  163.         }
  164.     }
  166.     /**
  167.      * @return array
  168.      */
  169.     public function toArray(): array
  170.     {
  171.         return array_map(function ($item) {
  172.             /** @var AbstractDataObject $item */
  173.             return $this->is_type_primitive ? $item : $item->toArray();
  174.         }, $this->items);
  175.     }
  177.     /**
  178.      * @return array
  179.      */
  180.     public function toRequestArray(): array
  181.     {
  182.         return array_map(function ($item) {
  183.             return $this->is_type_primitive ? $item : $item->toRequestArray();
  184.         }, $this->items);
  185.     }
  187.     #region Interface Iterator
  189.     /**
  190.      * @inheritDoc
  191.      */
  192.     public function current()
  193.     {
  194.         return current($this->items);
  195.     }
  197.     /**
  198.      * @inheritDoc
  199.      */
  200.     public function next()
  201.     {
  202.         next($this->items);
  203.     }
  205.     /**
  206.      * @inheritDoc
  207.      */
  208.     public function key(): int
  209.     {
  210.         return key($this->items);
  211.     }
  213.     /**
  214.      * @inheritDoc
  215.      */
  216.     public function valid(): bool
  217.     {
  218.         return current($this->items) !== false;
  219.     }
  221.     /**
  222.      * @inheritDoc
  223.      */
  224.     public function rewind()
  225.     {
  226.         reset($this->items);
  227.     }
  229.     #endregion
  231.     #region Interface ArrayAccess
  233.     /**
  234.      * @inheritDoc
  235.      */
  236.     public function offsetExists($offset): bool
  237.     {
  238.         return isset($this->items[$offset]);
  239.     }
  241.     /**
  242.      * @inheritDoc
  243.      *
  244.      * @throws InvalidArgumentException
  245.      */
  246.     public function offsetGet($offset)
  247.     {
  248.         if (!is_integer($offset)) {
  249.             throw new InvalidArgumentException(
  250.                 'Offset must be a integer type, \'' . DataType::getType($offset) . '\' given'
  251.             );
  252.         }
  254.         return $this->items[$offset] ?? null;
  255.     }
  257.     /**
  258.      * @inheritDoc
  259.      *
  260.      * @throws InvalidArgumentException
  261.      */
  262.     public function offsetSet($offset, $value)
  263.     {
  264.         $this->checkItemApplicable($value);
  266.         if (is_null($offset)) {
  267.             $this->items[] = $value;
  269.             return;
  270.         }
  272.         if (!is_integer($offset)) {
  273.             throw new InvalidArgumentException(
  274.                 'Offset must be a integer type, \'' . DataType::getType($offset) . '\' given'
  275.             );
  276.         }
  278.         if ($offset >= count($this->items)) {
  279.             throw new InvalidArgumentException('Array offset out of bounds');
  280.         }
  282.         $this->items[$offset] = $value;
  283.     }
  285.     /**
  286.      * @inheritDoc
  287.      *
  288.      * @throws InvalidArgumentException
  289.      */
  290.     public function offsetUnset($offset)
  291.     {
  292.         if (!is_integer($offset)) {
  293.             throw new InvalidArgumentException(
  294.                 'Offset must be a integer type, \'' . DataType::getType($offset) . '\' given'
  295.             );
  296.         }
  298.         unset($this->items[$offset]);
  300.         // to order elements of array
  301.         $this->items = array_values($this->items);
  302.     }
  304.     #endregion
  306.     #region Interface Countable
  308.     /**
  309.      * @inheritDoc
  310.      */
  311.     public function count(): int
  312.     {
  313.         return count($this->items);
  314.     }
  316.     #endregion
  317. }