GoetasWebservices\XML\XSDReader\Schema\Type\Type

Complexity

Total Complexity

17

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Test Coverage

Coverage

84.31%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	setAbstract()	0	4	1
A	loadTypeWithCallbackOnChildNodes()	0	12	2
A	getExtension()	0	3	1
A	setRestriction()	0	4	1
A	__construct()	0	4	2
A	getName()	0	3	1
A	setExtension()	0	4	1
A	getParent()	0	3	2
B	loadTypeWithCallback()	0	25	3
A	getRestriction()	0	3	1
A	isAbstract()	0	3	1

<?php
namespace GoetasWebservices\XML\XSDReader\Schema\Type;

use Closure;
use DOMNode;
use DOMElement;
use GoetasWebservices\XML\XSDReader\SchemaReader;
use GoetasWebservices\XML\XSDReader\Schema\Schema;
use GoetasWebservices\XML\XSDReader\Schema\SchemaItem;
use GoetasWebservices\XML\XSDReader\Schema\SchemaItemTrait;
use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Extension;
use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Restriction;
abstract class Type implements SchemaItem
{
    use SchemaItemTrait;

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

    /**
    * @var bool
    */
    protected $abstract = false;

    /**
     *
     * @var Restriction|null
     */
    protected $restriction;

    /**
     *
     * @var Extension|null
     */
    protected $extension;

    /**
    * @param string|null $name
    */
    public function __construct(Schema $schema, $name = null)
    {
        $this->name = $name?:null;
        $this->schema = $schema;
    }

    /**
    * @return string|null
    */
    public function getName()
    {
        return $this->name;
    }

    public function __toString()
    {
        return strval($this->name);
    }

    /**
    * @return bool
    */
    public function isAbstract()
    {
        return $this->abstract;
    }

    /**
    * @param bool $abstract
    *
    * @return $this
    */
    public function setAbstract($abstract)
    {
        $this->abstract = $abstract;
        return $this;
    }

    /**
     *
     * @return Restriction|Extension|null
    */
    public function getParent()
    {
        return $this->restriction ?  : $this->extension;
    }

    /**
    * @return Restriction|null
    */
    public function getRestriction()
    {
        return $this->restriction;
    }

    /**
    * @return $this
    */
    public function setRestriction(Restriction $restriction)
    {
        $this->restriction = $restriction;
        return $this;
    }

    /**
    * @return Extension|null
    */
    public function getExtension()
    {
        return $this->extension;
    }

    /**
    * @return $this
    */
    public function setExtension(Extension $extension)
    {
        $this->extension = $extension;
        return $this;
    }

    public static function loadTypeWithCallbackOnChildNodes(
        SchemaReader $schemaReader,
        Schema $schema,
        DOMNode $node,
        Closure $callback
    ) {
        foreach ($node->childNodes as $childNode) {
            static::loadTypeWithCallback(
                $schemaReader,
                $schema,
                $childNode,
                $callback
            );
        }
    }

    public static function loadTypeWithCallback(
        SchemaReader $schemaReader,
        Schema $schema,
        DOMNode $childNode,
        Closure $callback
    ) {
        if (! ($childNode instanceof DOMElement)) {
            return;
        }
        $methods = [
            'complexType' => 'loadComplexType',
            'simpleType' => 'loadSimpleType',
        ];

        $func = $schemaReader->maybeCallMethod(
            $methods,
            $childNode->localName,
            $childNode,
            $schema,
            $childNode,
            $callback
        );

        if ($func instanceof Closure) {
            call_user_func($func);
        }
    }
}