Graphp\Graph\AbstractGraph

Complexity

Total Complexity

49

Size/Duplication

Total Lines	430
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	addVertex()	0	8	2
A	assertVertexExists()	0	6	2
A	containsVertex()	0	3	1
A	vertexSet()	0	3	1
A	getEdgeSource()	0	3	1
A	edgeSet()	0	3	1
A	removeAllVertices()	0	7	2
A	addEdge()	0	24	6
A	createEdgeSpecifics()	0	3	2
A	createSpecifics()	0	3	2
A	outgoingEdgesOf()	0	4	1
A	getVertexSupplier()	0	3	1
A	getEdgeWeight()	0	3	1
A	getAllEdges()	0	3	1
A	incomingEdgesOf()	0	4	1
A	__construct()	0	10	1
A	getEdgeTarget()	0	3	1
A	edgesOf()	0	4	1
A	getEdge()	0	3	1
A	getEdgeSupplier()	0	3	1
A	removeVertex()	0	9	2
A	setEdgeWeight()	0	3	1
A	containsEdge()	0	9	4
A	removeEdge()	0	18	5
A	removeAllEdges()	0	23	6
A	getType()	0	3	1

<?php

namespace Graphp\Graph;

use InvalidArgumentException;
use Graphp\GraphInterface;
use Graphp\Graph\Specifics\SpecificsInterface;
use Graphp\Graph\Specifics\UndirectedSpecifics;
use Graphp\Graph\Specifics\DirectedSpecifics;
use Graphp\Edge\EdgeInterface;
use Graphp\Edge\EdgeSet;
use Graphp\Edge\Specifics\EdgeSpecificsInterface;
use Graphp\Edge\Specifics\UniformEdgeSpecifics;
use Graphp\Edge\Specifics\WeightedEdgeSpecifics;
use Graphp\Vertex\VertexInterface;
use Graphp\Vertex\VertexSet;
use Graphp\Util\SupplierInterface;

/**
 * Class AbstractGraph
 *
 * @package Graphp\Graph
 */
class AbstractGraph implements GraphInterface
{
    /**
     * The vertex supplier
     *
     * @var SupplierInterface
     */
    private $vertexSupplier;

    /**
     * The edge supplier
     *
     * @var SupplierInterface
     */
    private $edgeSupplier;

    /**
     * The graph type
     *
     * @var GraphTypeInterface
     */
    private $type;

    /**
     * The graph specifics
     *
     * @var SpecificsInterface
     */
    private $specifics;

    /**
     * The edge specifics
     *
     * @var EdgeSpecificsInterface
     */
    private $edgeSpecifics;

    /**
     * Construct a new graph
     *
     * @param SupplierInterface $vertexSupplier - the vertex supplier
     * @param SupplierInterface $edgeSupplier - the edge supplier
     * @param GraphTypeInterface $type - the graph type
     */
    protected function __construct(
        ?SupplierInterface $vertexSupplier = null,
        ?SupplierInterface $edgeSupplier = null,
        ?GraphTypeInterface $type = null
    ) {
        $this->vertexSupplier = $vertexSupplier;
        $this->edgeSupplier = $edgeSupplier;
        $this->type = $type;
        $this->specifics = $this->createSpecifics($type->isDirected());

The method isDirected() does not exist on null.

        $this->edgeSpecifics = $this->createEdgeSpecifics($type->isWeighted());
    }

    /**
     * Get the graph specifics
     *
     * @param bool $isDirected - is directed graph?
     *
     * @return SpecificsInterface
     */
    public function createSpecifics(bool $isDirected): SpecificsInterface
    {
        return $isDirected ? new DirectedSpecifics($this) : new UndirectedSpecifics($this);
    }

    /**
     * Get the edge specifics
     *
     * @param bool $isWeighted - is weighted?
     *
     * @return EdgeSpecificsInterface
     */
    public function createEdgeSpecifics(bool $isWeighted): EdgeSpecificsInterface
    {
        return $isWeighted ? new WeightedEdgeSpecifics($this) : new UniformEdgeSpecifics($this);

The call to Graphp\Edge\Specifics\WeightedEdgeSpecifics::__construct() has too many arguments starting with $this.

The call to Graphp\Edge\Specifics\UniformEdgeSpecifics::__construct() has too many arguments starting with $this.

    }

    /**
     * Get all edges connecting the source vertext to the target vertex
     *
     * @return EdgeSet
     */
    public function getAllEdges(VertexInterface $sourceVertex, VertexInterface $targetVertex): EdgeSet
    {
        return $this->specifics->getAllEdges($sourceVertex, $targetVertex);
    }

    /**
     * Get an edge connecting the source vertext to the target vertex
     *
     * @return null|EdgeInterface
     */
    public function getEdge(VertexInterface $sourceVertex, VertexInterface $targetVertex): ?EdgeInterface
    {
        return $this->specifics->getEdge($sourceVertex, $targetVertex);
    }

    /**
     * Get the vertex supplier that the graph uses whenever it needs to create new vertices
     *
     * @return null|SupplierInterface
     */
    public function getVertexSupplier(): ?SupplierInterface
    {
        return $this->vertexSupplier;
    }

    /**
     * Get the edge supplier that the graph uses whenever it needs to create new edges
     *
     * @return SupplierInterface
     */
    public function getEdgeSupplier(): SupplierInterface
    {
        return $this->edgeSupplier;
    }

    /**
     * Get the graph type
     *
     * @return GraphTypeInterface
     */
    public function getType(): GraphTypeInterface
    {
        return $this->type;
    }

    /**
     * Create a new edge in the graph. Return the newly created edge if added to the graph.
     *
     * @return EdgeInterface
     *
     * @throws InvalidArgumentException
     */
    public function addEdge(
        VertexInterface $sourceVertex,
        VertexInterface $targetVertex,
        ?EdgeInterface $edge = null
    ): ?EdgeInterface {
        $this->assertVertexExists($sourceVertex);
        $this->assertVertexExists($targetVertex);
        
        if (!$this->getType()->isAllowingMultipleEdges() && $this->containsEdge($sourceVertex, $targetVertex)) {
            return null;
        }
        
        if (!$this->getType()->isAllowingSelfLoops() && $sourceVertex->equals($targetVertex)) {
            throw new InvalidArgumentException("loops are not allowed");
        }
        
        $targetEdge = $edge ?? $this->edgeSupplier->get();

        if ($this->edgeSpecifics->add($targetEdge, $sourceVertex, $targetVertex)) {
            $this->specifics->addEdgeToTouchingVertices($targetEdge);
            return $targetEdge;
        }
                
        return null;
    }

    /**
     * Create and return a new vertex in the graph.
     *
     * @return null|VertexInterface
     */
    public function addVertex(VertexInterface $vertex): ?VertexInterface
    {
        if (!$this->containsVertex($vertex)) {
            $this->specifics->addVertex($vertex);
            return $vertex;
        }
        
        return null;
    }

    /**
     * Check if the graph contains the given edge, specified either by two vertices or by the edge itself
     *
     * @param VertexInterface $sourceVertex - the source vertex
     * @param VertexInterface $targetVertex - the target vertex
     * @param EdgeInterface $edge - the edge
     *
     * @return bool
     */
    public function containsEdge(
        ?VertexInterface $sourceVertex = null,
        ?VertexInterface $targetVertex = null,
        ?EdgeInterface $edge = null
    ): bool {
        if (!is_null($sourceVertex) && !is_null($targetVertex)) {
            return !is_null($this->getEdge($sourceVertex, $targetVertex));
        }
        return !is_null($edge) ? $this->edgeSpecifics->containsEdge($edge) : false;
    }

    /**
     * Check if the graph contains the given vertex
     *
     * @return bool
     */
    public function containsVertex(VertexInterface $vertex): bool
    {
        return $this->specifics->getVertexSet()->contains($vertex);
    }

    /**
     * Get a set of all edges touching the specified vertex
     *
     * @param VertexInterface - the vertex

The doc comment - at position 0 could not be parsed: Unknown type name '-' at position 0 in -.

     *
     * @return EdgeSet
     */
    public function edgesOf(VertexInterface $vertex): EdgeSet
    {
        $this->assertVertexExists($vertex);
        return $this->specifics->edgesOf($vertex);
    }

    /**
     * Get a set of all edges incoming into the specified vertex
     *
     * @param VertexInterface $vertex - the vertex
     *
     * @return EdgeSet
     */
    public function incomingEdgesOf(VertexInterface $vertex): EdgeSet
    {
        $this->assertVertexExists($vertex);
        return $this->specifics->incomingEdgesOf($vertex);
    }

    /**
     * Get a set of all edges outgoing from the specified vertex
     *
     * @param VertexInterface $vertex - the vertex
     *
     * @return EdgeSet
     */
    public function outgoingEdgesOf(VertexInterface $vertex): EdgeSet
    {
        $this->assertVertexExists($vertex);
        return $this->specifics->outgoingEdgesOf($vertex);
    }

    /**
     * Remove all edges specified by two vertices or the the list of edges themselves.
     * Return true, if graph was changed
     *
     * @param VertexInterface $vertex - the source vertex
     * @param VertexInterface $vertex - the target vertex
     * @param EdgeSet $edges - the edges
     *
     * @return bool
     */
    public function removeAllEdges(
        ?VertexInterface $sourceVertex = null,
        ?VertexInterface $targetVertex = null,
        ?EdgeSet $edges = null
    ): bool {
        $changed = false;
        if (!is_null($sourceVertex) && !is_null($targetVertex)) {
            $edge = $this->getEdge($sourceVertex, $targetVertex);
            if (!is_null($edge)) {
                $this->specifics->removeEdgeFromTouchingVertices($edge);
                $this->edgeSpecifics->remove($edge);
                return true;
            }
        } else {
            foreach ($edges as $edge) {
                if ($this->containsEdge(null, null, $edge)) {
                    $this->specifics->removeEdgeFromTouchingVertices($edge);
                    $this->edgeSpecifics->remove($edge);
                    $changed = true;
                }
            }
        }
        return $changed;
    }

    /**
     * Remove all specified vertices contained in the graph.
     * Return true, if graph was changed
     *
     * @param VertexSet $vertices - the vertices
     *
     * @return bool
     */
    public function removeAllVertices(VertexSet $vertices): bool
    {
        $changed = false;
        foreach ($vertices as $vertex) {
            $changed = $this->removeVertex($vertex);
        }
        return $changed;
    }

    /**
     * Remove the specifeid edge from the graph.
     * Return the edge, if it was removed
     *
     * @param VertexInterface $sourceVertex - the source vertex
     * @param VertexInterface $targetVertex - the target vertex
     * @param EdgeInterface $edge - the edge
     *
     * @return null|EdgeInterface
     */
    public function removeEdge(
        ?VertexInterface $sourceVertex = null,
        ?VertexInterface $targetVertex = null,
        ?EdgeInterface $edge = null
    ): ?EdgeInterface {
        if (!is_null($sourceVertex) && !is_null($targetVertex)) {
            $edge = $this->getEdge($sourceVertex, $targetVertex);
            if (!is_null($edge)) {
                $this->specifics->removeEdgeFromTouchingVertices($edge);
                $this->edgeSpecifics->remove($edge);
                return $edge;
            }
        } elseif (!is_null($edge)) {
            $this->specifics->removeEdgeFromTouchingVertices($edge);
            $this->edgeSpecifics->remove($edge);
            return $edge;
        }
        return null;
    }

    /**
     * Remove the specifeid vertex from the graph.
     * Return the true, if it was removed
     *
     * @param VertexInterface $vertex - the vertex
     *
     * @return bool
     */
    public function removeVertex(VertexInterface $vertex): bool
    {
        if ($this->containsVertex($vertex)) {
            $edges = $this->edgesOf($vertex);
            $this->removeAllEdges(null, null, $edges);
            $this->specifics->removeVertex($vertex);
            return true;
        }
        return false;
    }

    /**
     * Get the set of edges contained in the graph
     *
     * @return EdgeSet
     */
    public function edgeSet(): EdgeSet
    {
        return $this->edgeSpecifics->getEdgeSet();
    }

    /**
     * Get the set of vertices contained in the graph
     *
     * @return VertexSet
     */
    public function vertexSet(): VertexSet
    {
        return $this->specifics->getVertexSet();
    }

    /**
     * Get the edge source vertex
     *
     * @param EdgeInterface $edge - the edge
     *
     * @return VertexInterface
     */
    public function getEdgeSource(EdgeInterface $edge): VertexInterface
    {
        return $this->edgeSpecifics->getEdgeSource($edge);
    }

    /**
     * Get the edge target vertex
     *
     * @param EdgeInterface $edge - the edge
     *
     * @return VertexInterface
     */
    public function getEdgeTarget(EdgeInterface $edge): VertexInterface
    {
        return $this->edgeSpecifics->getEdgeTarget($edge);
    }

    /**
     * Get the edge weight
     *
     * @param EdgeInterface $edge - the edge
     *
     * @return null|float
     */
    public function getEdgeWeight(EdgeInterface $edge): ?float
    {
        return $this->edgeSpecifics->getEdgeWeight($edge);
    }

    /**
     * Set the edge weight
     *
     * @param EdgeInterface $edge - the edge
     * @param float $weight - the edge weight
     */
    public function setEdgeWeight(EdgeInterface $edge, ?float $weight = null): void
    {
        $this->edgeSpecifics->setEdgeWeight($edge, $weight);
    }

    /**
     * Assert the the vertex exists
     *
     * @param VertexInterface - the vertex

The doc comment - at position 0 could not be parsed: Unknown type name '-' at position 0 in -.

     *
     * @return bool
     *
     * @throws InvalidArgumentException
     */
    private function assertVertexExists(VertexInterface $vertex): bool
    {
        if ($this->containsVertex($vertex)) {
            return true;
        } else {
            throw new InvalidArgumentException("no such vertex in graph");
        }
    }
}