graphp\graph\builder\GraphBuilder

Complexity

Total Complexity

14

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	addEdge()	0	14	2
A	removeVertex()	0	4	1
A	addGraph()	0	4	1
A	addVertex()	0	4	1
A	removeEdge()	0	7	1
A	removeVertices()	0	6	2
A	addVertices()	0	6	2
A	__construct()	0	3	1
A	addEdgeChain()	0	9	2
A	build()	0	3	1

<?php

namespace graphp\graph\builder;

use graphp\GraphInterface;
use graphp\GraphUtils;
use graphp\edge\EdgeInterface;
use graphp\vertex\VertexInterface;
use graphp\vertex\VertexSet;

/**
 * Class GraphBuilder
 *
 * @package graphp\graph
 */
class GraphBuilder
{
    /**
     * The graph
     *
     * @var GraphInterface
     */
    private $graph;
    
    /**
     * Construct the graph
     *
     * @param GraphInterface $graph - the graph
     */
    public function __construct(GraphInterface $graph)
    {
        $this->graph = $graph;
    }

    /**
     * Add a vertex to the graph being built
     *
     * @param VertexInterface $vertex - the vertex
     *
     * @return self
     */
    public function addVertex(VertexInterface $vertex): self
    {
        $this->graph->addVertex($vertex);
        return $this;
    }

    /**
     * Add vertices to the graph being built
     *
     * @param VertexSet $vertices - the vertices
     *
     * @return self
     */
    public function addVertices(VertexSet $vertices): self
    {
        foreach ($vertices as $vertex) {
            $this->addVertex($vertex);
        }
        return $this;
    }

    /**
     * Add an edge to the graph being built
     *
     * @param VertexInterface $vertex - the source vertex
     * @param VertexInterface $targetVertex - the target vertex
     * @param EdgeInterface $edge - the edge to be added
     *
     * @return self
     */
    public function addEdge(
        VertexInterface $sourceVertex,
        VertexInterface $targetVertex,
        ?EdgeInterface $edge = null,
        ?float $weight = null
    ): self {
        if (is_null($edge)) {
            GraphUtils::addEdgeWithVertices($this->graph, $sourceVertex, $targetVertex, $weight);
        } else {
            $this->addVertex($sourceVertex);
            $this->addVertex($targetVertex);
            $this->graph->addEdge($sourceVertex, $targetVertex, $edge);
        }
        return $this;
    }

    /**
     * Add an chain of edges to the graph being built
     *
     * @param VertexInterface $first - the first vertex
     * @param VertexInterface $second - the second vertex
     * @param mixed $vertices - the remaining vertices
     *
     * @return self
     */
    public function addEdgeChain(VertexInterface $first, VertexInterface $second, ...$vertices): self
    {
        $this->addEdge($first, $second);
        $last = $second;
        foreach ($vertices as $vertex) {
            $this->addEdge($last, $vertex);
            $last = $vertex;
        }
        return $this;
    }

    /**
     * Add all the vertices and all the edges of the specified graph to the graph being built
     *
     * @param GraphInterface $sourceGraph - the graph
     *
     * @return self
     */
    public function addGraph(GraphInterface $sourceGraph): self
    {
        GraphUtils::addGraph($this->graph, $sourceGraph);
        return $this;
    }

    /**
     * Remove the specified vertex from the graph being built
     *
     * @param VertexInterface $vertex - the vertex to remove
     *
     * @return self
     */
    public function removeVertex(VertexInterface $vertex): self
    {
        $this->graph->removeVertex($vertex);
        return $this;
    }

    /**
     * Remove vertices from the graph being built
     *
     * @param VertexSet $vertices - the vertices to remove
     *
     * @return self
     */
    public function removeVertices(VertexSet $vertices): self
    {
        foreach ($vertices as $vertex) {
            $this->removeVertex($vertex);
        }
        return $this;
    }

    /**
     * Remove the edge from the graph being built
     *
     * @param VertexInterface $sourceVertex - the edge source vertex
     * @param VertexInterface $tagretVertex - the edge target vertex
     * @param EdgeInterface $edge - the edge
     *
     * @return self
     */
    public function removeEdge(
        ?VertexInterface $sourceVertex = null,
        ?VertexInterface $targetVertex = null,
        ?EdgeInterface $edge = null
    ): self {
        $this->graph->removeEdge($sourceVertex, $targetVertex, $edge);
        return $this;
    }

    /**
     * Get the graph being built
     *
     * @return GraphInterface
     */
    public function build(): GraphInterface
    {
        return $this->graph;
    }
}