vendor/easycorp/easyadmin-bundle/src/Collection/FieldCollection.php line 100

Open in your IDE?
  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Collection;
  5. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Collection\CollectionInterface;
  6. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Field\FieldInterface;
  7. use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
  8. use EasyCorp\Bundle\EasyAdminBundle\Field\Field;
  10. /**
  11.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  12.  */
  13. final class FieldCollection implements CollectionInterface
  14. {
  15.     /** @var FieldDto[] */
  16.     private $fields;
  18.     /**
  19.      * @param FieldInterface[]|string[] $fields
  20.      */
  21.     private function __construct(iterable $fields)
  22.     {
  23.         $this->fields = $this->processFields($fields);
  24.     }
  26.     public function __clone()
  27.     {
  28.         $clonedFields = [];
  29.         foreach ($this->fields as $fieldDto) {
  30.             $clonedFieldDto = clone $fieldDto;
  31.             $clonedFields[$clonedFieldDto->getUniqueId()] = $clonedFieldDto;
  32.         }
  34.         $this->fields = $clonedFields;
  35.     }
  37.     /**
  38.      * @param FieldInterface[]|string[] $fields
  39.      */
  40.     public static function new(iterable $fields): self
  41.     {
  42.         return new self($fields);
  43.     }
  45.     public function get(string $fieldUniqueId): ?FieldDto
  46.     {
  47.         return $this->fields[$fieldUniqueId] ?? null;
  48.     }
  50.     /**
  51.      * It returns the first field associated to the given property or null if none found.
  52.      * Some pages (index/detail) can render the same field more than once.
  53.      * In those cases, this method always returns the first field occurrence.
  54.      */
  55.     public function getByProperty(string $propertyName): ?FieldDto
  56.     {
  57.         foreach ($this->fields as $field) {
  58.             if ($propertyName === $field->getProperty()) {
  59.                 return $field;
  60.             }
  61.         }
  63.         return null;
  64.     }
  66.     public function set(FieldDto $newOrUpdatedField): void
  67.     {
  68.         $this->fields[$newOrUpdatedField->getUniqueId()] = $newOrUpdatedField;
  69.     }
  71.     public function unset(FieldDto $removedField): void
  72.     {
  73.         unset($this->fields[$removedField->getUniqueId()]);
  74.     }
  76.     public function prepend(FieldDto $newField): void
  77.     {
  78.         $this->fields = array_merge([$newField->getUniqueId() => $newField], $this->fields);
  79.     }
  81.     public function first(): ?FieldDto
  82.     {
  83.         if (empty($this->fields)) {
  84.             return null;
  85.         }
  87.         return $this->fields[array_key_first($this->fields)];
  88.     }
  90.     public function isEmpty(): bool
  91.     {
  92.         return 0 === \count($this->fields);
  93.     }
  95.     public function offsetExists($offset): bool
  96.     {
  97.         return \array_key_exists($offset, $this->fields);
  98.     }
  100.     public function offsetGet($offset)
  101.     {
  102.         return $this->fields[$offset];
  103.     }
  105.     public function offsetSet($offset, $value): void
  106.     {
  107.         $this->fields[$offset] = $value;
  108.     }
  110.     public function offsetUnset($offset): void
  111.     {
  112.         unset($this->fields[$offset]);
  113.     }
  115.     public function count(): int
  116.     {
  117.         return \count($this->fields);
  118.     }
  120.     /**
  121.      * @return \ArrayIterator|\Traversable|FieldDto[]
  122.      */
  123.     public function getIterator()
  124.     {
  125.         return new \ArrayIterator($this->fields);
  126.     }
  128.     /**
  129.      * @param FieldInterface[]|string[] $fields
  130.      *
  131.      * @return FieldDto[]
  132.      */
  133.     private function processFields(iterable $fields): array
  134.     {
  135.         $dtos = [];
  137.         // for DX reasons, fields can be configured as a FieldInterface object and
  138.         // as a simple string with the name of the Doctrine property
  139.         /** @var FieldInterface|string $field */
  140.         foreach ($fields as $field) {
  141.             if (\is_string($field)) {
  142.                 $field = Field::new($field);
  143.             }
  145.             $dto = $field->getAsDto();
  146.             if (null === $dto->getFieldFqcn()) {
  147.                 $dto->setFieldFqcn(\get_class($field));
  148.             }
  149.             $dtos[$dto->getUniqueId()] = $dto;
  150.         }
  152.         return $dtos;
  153.     }
  154. }