Tebru\Gson\TypeAdapter\ReflectionTypeAdapter

Complexity

Total Complexity

37

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	canCache()	0	3	1
D	read()	0	63	18
A	__construct()	0	11	1
C	write()	0	47	17

<?php
/*
 * Copyright (c) Nate Brunette.
 * Distributed under the MIT License (http://opensource.org/licenses/MIT)
 */

declare(strict_types=1);

namespace Tebru\Gson\TypeAdapter;

use Tebru\Gson\Context\ReaderContext;
use Tebru\Gson\Context\WriterContext;
use Tebru\Gson\Internal\Data\Property;
use Tebru\Gson\Internal\DefaultClassMetadata;
use Tebru\Gson\Internal\ObjectConstructor;
use Tebru\Gson\Internal\ObjectConstructor\CreateFromInstance;
use Tebru\Gson\Internal\ObjectConstructorAware;
use Tebru\Gson\Internal\ObjectConstructorAwareTrait;
use Tebru\Gson\TypeAdapter;
use TypeError;

/**
 * Class ReflectionTypeAdapter
 *
 * Uses reflected class properties to read/write object
 *
 * @author Nate Brunette <n@tebru.net>
 */
class ReflectionTypeAdapter extends TypeAdapter implements ObjectConstructorAware
{
    use ObjectConstructorAwareTrait;

    /**
     * @var DefaultClassMetadata
     */
    protected $classMetadata;

    /**
     * @var Property[]
     */
    protected $properties;

    /**
     * @var null|string
     */
    protected $classVirtualProperty;

    /**
     * @var bool
     */
    protected $skipSerialize;

    /**
     * @var bool
     */
    protected $skipDeserialize;

    /**
     * Constructor
     *
     * @param ObjectConstructor $objectConstructor
     * @param DefaultClassMetadata $classMetadata
     * @param null|string $classVirtualProperty
     */
    public function __construct(
        ObjectConstructor $objectConstructor,
        DefaultClassMetadata $classMetadata,
        ?string $classVirtualProperty
    ) {
        $this->objectConstructor = $objectConstructor;
        $this->classVirtualProperty = $classVirtualProperty;
        $this->classMetadata = $classMetadata;
        $this->properties = $classMetadata->properties->elements;
        $this->skipSerialize = $classMetadata->skipSerialize;
        $this->skipDeserialize = $classMetadata->skipDeserialize;
    }

    /**
     * Read the next value, convert it to its type and return it
     *
     * @param array $value
     * @param ReaderContext $context
     * @return object
     */
    public function read($value, ReaderContext $context)
    {
        if ($this->skipDeserialize || $value === null) {
            return null;
        }

        if ($this->classVirtualProperty !== null) {
            $value = array_shift($value);
        }

        $object = $this->objectConstructor->construct();
        $usesExisting = $context->usesExistingObject;
        $enableScalarAdapters = $context->enableScalarAdapters;
        $typeAdapterProvider = $context->typeAdapterProvider;
        $excluder = $context->getExcluder();
        $payload = $context->getPayload();

        if ($this->classMetadata->hasExclusions && $excluder->skipClassDeserializeByStrategy($this->classMetadata, $object, $payload)) {

The property hasExclusions does not seem to exist on Tebru\Gson\Internal\DefaultClassMetadata.

            return null;
        }

        foreach ($value as $name => $item) {
            $property = $this->properties[$name] ?? null;

            if ($property === null || $property->skipDeserialize) {
                continue;
            }

            if ($property->hasExclusions && $excluder->skipPropertyDeserializeByStrategy($property, $object, $payload)) {

The property hasExclusions does not seem to exist on Tebru\Gson\Internal\Data\Property.

                continue;
            }

            $adapter = $property->adapter;

            if ($adapter === null) {
                // disabled scalar adapters
                if ($property->isScalar && !$enableScalarAdapters) {
                    $property->setterStrategy->set($object, $item);
                    continue;
                }

                $adapter = $property->adapter = $typeAdapterProvider->getAdapterFromProperty($property);
            }

            if ($usesExisting && $adapter instanceof ObjectConstructorAware) {
                try {
                    $nestedObject = $property->getterStrategy->get($object);
                } /** @noinspection BadExceptionsProcessingInspection */ catch (TypeError $error) {
                    // this may occur when attempting to get a nested object that doesn't exist and
                    // the method return is not nullable. The type error only occurs because we are
                    // may be calling the getter before data exists.
                    $nestedObject = null;
                }

                if ($nestedObject !== null) {
                    $adapter->setObjectConstructor(new CreateFromInstance($nestedObject));
                }
            }

            $property->setterStrategy->set($object, $adapter->read($item, $context));
        }

        return $object;
    }

    /**
     * Write the value to the writer for the type
     *
     * @param object $value
     * @param WriterContext $context
     * @return array|null
     */
    public function write($value, WriterContext $context): ?array
    {
        if ($this->skipSerialize || $value === null) {
            return null;
        }

        $result = [];
        $serializeNull = $context->serializeNull();
        $enableScalarAdapters = $context->enableScalarAdapters();
        $typeAdapterProvider = $context->getTypeAdapterProvider();
        $excluder = $context->getExcluder();

        if ($this->classMetadata->hasExclusions && $excluder->skipClassSerializeByStrategy($this->classMetadata, $value)) {

The property hasExclusions does not seem to exist on Tebru\Gson\Internal\DefaultClassMetadata.

            return null;
        }

        foreach ($this->properties as $property) {
            if ($property->skipSerialize) {
                continue;
            }
            if ($property->hasExclusions && $excluder->skipPropertySerializeByStrategy($property, $value)) {

The property hasExclusions does not seem to exist on Tebru\Gson\Internal\Data\Property.

                continue;
            }

            $serializedName = $property->serializedName;
            $propertyValue = $property->getterStrategy->get($value);
            $isNull = $propertyValue === null;
            $adapter = $property->adapter;

            if ($adapter === null && ($enableScalarAdapters || !$property->isScalar)) {
                $adapter = $typeAdapterProvider->getAdapterFromProperty($property);
            }

            if (!$isNull && $adapter !== null) {
                $propertyValue = $adapter->write($propertyValue, $context);
            }

            if ($serializeNull || !$isNull) {
                $result[$serializedName] = $propertyValue;
            }
        }

        if ($this->classVirtualProperty !== null) {
            $result = [$this->classVirtualProperty => $result];
        }

        return $result;
    }

    /**
     * Return true if object can be written to disk
     *
     * @return bool
     */
    public function canCache(): bool
    {
        return $this->objectConstructor->canCache();
    }
}