gossi\codegen\model\parts\InterfacesPart

Complexity

Total Complexity

16

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

84.21%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
	addUseStatement()	0	1	?
	removeUseStatement()	0	1	?
	getNamespace()	0	1	?
A	initInterfaces()	0	3	1
A	addInterface()	0	13	2
A	getInterfaces()	0	3	1
A	getPhpInterfaces()	0	10	3
A	hasInterfaces()	0	3	1
A	hasInterface()	0	8	4
A	removeInterface()	0	14	2
A	setInterfaces()	0	7	2

<?php
declare(strict_types=1);

namespace gossi\codegen\model\parts;

use gossi\codegen\model\PhpInterface;
use phootwork\collection\Set;

/**
 * Interfaces part
 *
 * For all models that can contain interfaces
 *
 * @author Thomas Gossmann
 */
trait InterfacesPart {

	/** @var Set|string[] */
	private $interfaces;

	private function initInterfaces() {
		$this->interfaces = new Set();
	}

	/**
	 * Adds a use statement with an optional alias
	 *
	 * @param string $qualifiedName
	 * @param null|string $alias
	 * @return $this
	 */
	abstract public function addUseStatement($qualifiedName, string $alias = null);

	/**
	 * Removes a use statement
	 *
	 * @param string $qualifiedName
	 * @return $this
	 */
	abstract public function removeUseStatement(string $qualifiedName);

	/**
	 * Returns the namespace
	 *
	 * @return string
	 */
	abstract public function getNamespace(): ?string;

	/**
	 * Adds an interface.
	 *
	 * If the interface is passed as PhpInterface object,
	 * the interface is also added as use statement.
	 *
	 * @param PhpInterface|string $interface interface or qualified name
	 * @return $this
	 */
	public function addInterface($interface) {
		if ($interface instanceof PhpInterface) {
			$name = $interface->getName();
			$qname = $interface->getQualifiedName();
			$this->addUseStatement($qname);
		} else {
			$name = $interface;
		}

		$this->interfaces->add($name);

		return $this;
	}

	/**
	 * Returns the interfaces names
	 *
	 * @return Set|string[]
	 */
	public function getInterfaces(): Set {
		return $this->interfaces;
	}

    /**
     * @return iterable|PhpInterface[]
     */
    public function getPhpInterfaces(): iterable
    {
        $interfaces = [];
        foreach ($this->interfaces as $interface) {
            $interfaces[] = interface_exists($interface) ?
                PhpInterface::fromName($interface) : PhpInterface::create($interface);
        }

        return $interfaces;
    }

	/**
	 * Checks whether interfaces exists
	 *
	 * @return bool `true` if interfaces are available and `false` if not
	 */
	public function hasInterfaces(): bool {
		return !$this->interfaces->isEmpty();
	}

	/**
	 * Checks whether an interface exists
	 *
	 * @param PhpInterface|string $interface interface name or instance
	 * @return bool
	 */
	public function hasInterface($interface): bool {
		if ($interface instanceof PhpInterface) {
			return $this->interfaces->contains($interface->getName())
				|| $this->interfaces->contains($interface->getQualifiedName());
		}

		return $this->interfaces->contains($interface) || $this->hasInterface(new PhpInterface($interface));
	}

	/**
	 * Removes an interface.
	 *
	 * If the interface is passed as PhpInterface object,
	 * the interface is also remove from the use statements.
	 *
	 * @param PhpInterface|string $interface interface or qualified name
	 * @return $this
	 */
	public function removeInterface($interface) {
		if ($interface instanceof PhpInterface) {
			$name = $interface->getName();
			$qname = $interface->getQualifiedName();

			$this->removeUseStatement($qname);
		} else {
			$name = $interface;
		}

		$this->interfaces->remove($name);

		return $this;
	}

	/**
	 * Sets a collection of interfaces
	 *
	 * @param PhpInterface[] $interfaces
	 * @return $this
	 */
	public function setInterfaces(array $interfaces) {
		foreach ($interfaces as $interface) {
			$this->addInterface($interface);
		}

		return $this;
	}
}