cerbero90 / dto

src/Traits/TurnsIntoArray.php

<?php

namespace Cerbero\Dto\Traits;

use ArrayIterator;
use Cerbero\Dto\Exceptions\ImmutableDtoException;
use Cerbero\Dto\Exceptions\UnknownDtoPropertyException;
use Cerbero\Dto\Exceptions\UnsetDtoPropertyException;
use Cerbero\Dto\Manipulators\ArrayConverter;
use Traversable;

use const Cerbero\Dto\CAMEL_CASE_ARRAY;

The constant Cerbero\Dto\CAMEL_CASE_ARRAY was not found. Maybe you did not declare it correctly or list all dependencies?

use const Cerbero\Dto\MUTABLE;

The constant Cerbero\Dto\MUTABLE was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Trait to turn a DTO into an array.
 *
 */
trait TurnsIntoArray
{
    /**
     * Retrieve the DTO as an array
     *
     * @return array
     */
    public function toArray(): array
    {
        $data = [];
        $snakeCase = !($this->getFlags() & CAMEL_CASE_ARRAY);

It seems like getFlags() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        foreach ($this->getPropertiesMap() as $name => $property) {

It seems like getPropertiesMap() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $key = ArrayConverter::instance()->formatKey($name, $snakeCase);
            $data[$key] = ArrayConverter::instance()->convert($property->value(), $snakeCase);
        }

        return $data;
    }

    /**
     * Retrieve the DTO as an iterator
     *
     * @return Traversable
     */
    public function getIterator(): Traversable
    {
        return new ArrayIterator($this->toArray(), ArrayIterator::ARRAY_AS_PROPS);
    }

    /**
     * Determine whether a given property has a value
     *
     * @param mixed $property
     * @return bool
     */
    public function offsetExists($property): bool
    {
        return $this->has($property);

It seems like has() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Retrieve the given property value
     *
     * @param mixed $property
     * @return mixed
     * @throws UnknownDtoPropertyException
     */
    public function &offsetGet($property)
    {
        $value = $this->get($property);

It seems like get() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $value;
    }

    /**
     * Set the given property to the provided value
     *
     * @param mixed $property
     * @param mixed $value
     * @return void
     * @throws ImmutableDtoException
     * @throws UnknownDtoPropertyException
     */
    public function offsetSet($property, $value): void
    {
        if (!($this->getFlags() & MUTABLE)) {
            throw new ImmutableDtoException(static::class);
        }

        $this->set($property, $value);

It seems like set() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Set the given property to the provided value
     *
     * @param mixed $property
     * @return void
     * @throws ImmutableDtoException
     * @throws UnsetDtoPropertyException
     * @throws UnknownDtoPropertyException
     */
    public function offsetUnset($property): void
    {
        if (!($this->getFlags() & MUTABLE)) {
            throw new ImmutableDtoException(static::class);
        }

        $this->unset($property);

It seems like unset() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }
}