WsdlToPhp\PackageGenerator\Container\Model\Struct

Complexity

Total Complexity

21

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	addStructWithAttribute()	0	8	2
A	addVirtualStruct()	0	3	1
A	objectClass()	0	3	1
A	getVirtualKey()	0	3	1
A	addUnionStruct()	0	8	2
A	getVirtual()	0	5	2
A	getTypeKey()	0	3	1
A	addStruct()	0	8	3
A	getStructByName()	0	3	1
A	getObjectKeyWithType()	0	3	1
A	add()	0	10	2
A	getByType()	0	5	2
A	getObjectKeyWithVirtual()	0	3	1
A	getStructByNameAndType()	0	3	1

<?php

declare(strict_types=1);

namespace WsdlToPhp\PackageGenerator\Container\Model;

use WsdlToPhp\PackageGenerator\Model\Struct as Model;

final class Struct extends AbstractModel
{
    /**
     * Only for virtually-considered objects (in order to avoid duplications in objects property).
     */
    protected array $virtualObjects = [];

    public function getStructByName(string $name): ?Model
    {
        return $this->get($name);
    }

    public function getStructByNameAndType(string $name, string $type): ?Model
    {
        return $this->getByType($name, $type);
    }

    public function addVirtualStruct(string $structName, string $structType = ''): self
    {
        return $this->addStruct($structName, false, $structType);
    }

    public function addStruct(string $structName, bool $isStruct = true, string $structType = ''): self
    {
        if (null === (empty($structType) ? $this->get($structName) : $this->getByType($structName, $structType))) {
            $model = new Model($this->generator, $structName, $isStruct);
            $this->add($model->setInheritance($structType));
        }

        return $this;
    }

    public function addStructWithAttribute(string $structName, string $attributeName, string $attributeType): self
    {
        $this->addStruct($structName);
        if (($struct = $this->getStructByName($structName)) instanceof Model) {
            $struct->addAttribute($attributeName, $attributeType);
        }

        return $this;
    }

    public function addUnionStruct(string $structName, array $types): self
    {
        $this->addVirtualStruct($structName);
        if (($struct = $this->getStructByName($structName)) instanceof Model) {
            $struct->setTypes($types);
        }

        return $this;
    }

    public function getVirtual(string $value): ?Model
    {
        $key = $this->getVirtualKey($value);

        return array_key_exists($key, $this->virtualObjects) ? $this->virtualObjects[$key] : null;
    }

    public function getByType(string $value, string $type): ?Model
    {
        $key = $this->getTypeKey($value, $type);

        return array_key_exists($key, $this->objects) ? $this->objects[$key] : null;
    }

    public function getObjectKeyWithType(object $object, string $type): string
    {
        return $this->getTypeKey($this->getObjectKey($object), $type);
    }

    public function getObjectKeyWithVirtual(object $object): string
    {
        return $this->getVirtualKey($this->getObjectKey($object));
    }

    /**
     * The key must not conflict with possible key values.
     */
    public function getTypeKey(string $name, string $type): string
    {
        return sprintf('struct_name_%s-type_%s', $name, $type);
    }

    /**
     * The key must not conflict with possible key values.
     */
    public function getVirtualKey(string $name): string
    {
        return sprintf('virtual_struct_name_%s', $name);
    }

    /**
     * By overriding this method, we ensure that each time a new object is stored, it is stored with our new key if the inheritance is defined.
     *
     * @param Model $object
     *
     * @return Struct
     */
    public function add(object $object): self
    {
        $inheritance = $object->getInheritance();
        if (!empty($inheritance)) {
            $this->virtualObjects[$this->getObjectKeyWithVirtual($object)] = $this->objects[$this->getObjectKeyWithType($object, $object->getInheritance())] = $object;
        } else {
            parent::add($object);
        }

        return $this;
    }

    protected function objectClass(): string
    {
        return Model::class;
    }
}