Ivory\Serializer\Visitor\AbstractVisitor

Complexity

Total Complexity

17

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	prepare()	0	8	1
A	visitArray()	0	13	2
A	visitBoolean()	0	4	1
A	visitFloat()	0	4	1
A	visitInteger()	0	4	1
A	visitNull()	0	4	1
A	visitResource()	0	4	1
A	visitString()	0	4	1
A	startVisitingObject()	0	10	2
A	visitObjectProperty()	0	17	3
A	finishVisitingObject()	0	4	1
	doVisitArray()	0	1	?
	doVisitObjectProperty()	0	6	?
A	enterScope()	0	5	1
A	leaveScope()	0	5	1

<?php

/*
 * This file is part of the Ivory Serializer package.
 *
 * (c) Eric GELOEN <geloen.eric@gmail.com>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\Serializer\Visitor;

use Ivory\Serializer\Context\ContextInterface;
use Ivory\Serializer\Mapping\ClassMetadataInterface;
use Ivory\Serializer\Mapping\MetadataInterface;
use Ivory\Serializer\Mapping\PropertyMetadataInterface;
use Ivory\Serializer\Mapping\TypeMetadataInterface;
use Ivory\Serializer\Navigator\NavigatorInterface;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
abstract class AbstractVisitor implements VisitorInterface
{
    /**
     * @var \SplStack
     */
    private $dataStack;

    /**
     * @var \SplStack
     */
    private $metadataStack;

    /**
     * @var NavigatorInterface
     */
    protected $navigator;

    /**
     * {@inheritdoc}
     */
    public function prepare($data, ContextInterface $context)
    {
        $this->navigator = $context->getNavigator();
        $this->dataStack = $context->getDataStack();
        $this->metadataStack = $context->getMetadataStack();

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function visitArray($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        $this->enterScope($data, $type);

        if ($context->getExclusionStrategy()->skipType($type, $context)) {
            $data = [];
        }

        $result = $this->doVisitArray($data, $type, $context);
        $this->leaveScope();

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function visitBoolean($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        return $this->visitData((bool) $data, $type, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function visitFloat($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        return $this->visitData((float) $data, $type, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function visitInteger($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        return $this->visitData((int) $data, $type, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function visitNull($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        return $this->visitData(null, $type, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function visitResource($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        throw new \RuntimeException('(De)-Serializing a resource is not supported.');
    }

    /**
     * {@inheritdoc}
     */
    public function visitString($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        return $this->visitData((string) $data, $type, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function startVisitingObject($data, ClassMetadataInterface $class, ContextInterface $context)
    {
        if ($context->getExclusionStrategy()->skipClass($class, $context)) {
            return false;
        }

        $this->enterScope($data, $class);

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function visitObjectProperty($data, PropertyMetadataInterface $property, ContextInterface $context)
    {
        $visited = false;

        if (!$context->getExclusionStrategy()->skipProperty($property, $context)) {
            $this->enterScope($data, $property);

            $name = $property->hasAlias()
                ? $property->getAlias()
                : $context->getNamingStrategy()->convert($property->getName());

            $visited = $this->doVisitObjectProperty($data, $name, $property, $context);
            $this->leaveScope();
        }

        return $visited;
    }

    /**
     * {@inheritdoc}
     */
    public function finishVisitingObject($data, ClassMetadataInterface $class, ContextInterface $context)
    {
        $this->leaveScope();
    }

    /**
     * @param mixed                 $data
     * @param TypeMetadataInterface $type
     * @param ContextInterface      $context
     *
     * @return mixed
     */
    abstract protected function doVisitArray($data, TypeMetadataInterface $type, ContextInterface $context);

    /**
     * @param mixed                     $data
     * @param string                    $name
     * @param PropertyMetadataInterface $property
     * @param ContextInterface          $context
     *
     * @return bool
     */
    abstract protected function doVisitObjectProperty(
        $data,
        $name,
        PropertyMetadataInterface $property,
        ContextInterface $context
    );

    /**
     * @param mixed             $data
     * @param MetadataInterface $metadata
     */
    private function enterScope($data, MetadataInterface $metadata)
    {
        $this->dataStack->push($data);
        $this->metadataStack->push($metadata);
    }

    private function leaveScope()
    {
        $this->dataStack->pop();
        $this->metadataStack->pop();
    }
}