Graph::setEdges() - Code Metrics - janalis/doctrineviz - Measure and Improve Code Quality continuously with Scrutinizer

Graph::setEdges() A
last analyzed 2021-02-24 09:45 UTC

↳ Parent: Graph

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?php

/*
 * This file is part of the doctrineviz package
 *
 * Copyright (c) 2017 Pierre Hennequart
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Feel free to edit as you please, and have fun.
 *
 * @author Pierre Hennequart <[email protected]>
 */

declare(strict_types=1);

namespace Janalis\Doctrineviz\Graphviz;

class Graph implements GraphInterface
{
    use Attributable;

    /** @var VertexInterface[] */
    protected $vertices;

    /** @var EdgeInterface[] */
    protected $edges;

    /**
     * @return string
     */
    public function __toString()
    {
        return 'digraph g {'.PHP_EOL.(!count($this->getAttributes()) ? '' : implode(PHP_EOL, $this->indentAll($this->getAttributes())).
            PHP_EOL).(!count($this->getVertices()) ? '' : implode(PHP_EOL, $this->indentAll($this->getVertices())).
            PHP_EOL).(!count($this->getEdges()) ? '' : implode(PHP_EOL, $this->indentAll($this->getEdges())).
            PHP_EOL).'}';
    }

    /**
     * Create vertex.
     *
     * @param string $id
     *
     * @return VertexInterface
     */
    public function createVertex(string $id): VertexInterface
    {
        return new Vertex($id, $this);
    }

    /**
     * Get vertices.
     *
     * @return VertexInterface[]
     */
    public function getVertices(): array
    {
        if ($this->vertices) {

            ksort($this->vertices);
        }

        return $this->vertices ? array_values($this->vertices) : [];
    }

    /**
     * Set vertices.
     *
     * @param VertexInterface[] $vertices
     */
    public function setVertices(array $vertices): void
    {
        foreach ($vertices as $vertex) {
            $this->addVertex($vertex);
        }
    }

    /**
     * Get vertex.
     *
     * @param string $id
     *
     * @return VertexInterface
     */
    public function getVertex(string $id): ?VertexInterface
    {
        if (!array_key_exists($id, $this->vertices)) {
            return null;
        }

        return $this->vertices[$id];
    }

    /**
     * Add vertex.
     *
     * @param VertexInterface $vertex
     */
    public function addVertex(VertexInterface $vertex): void
    {
        $vertex->setGraph($this);
        $this->vertices[$vertex->getId()] = $vertex;
    }

    /**
     * Remove vertex.
     *
     * @param VertexInterface $vertex
     */
    public function removeVertex(VertexInterface $vertex): void
    {
        unset($this->vertices[$vertex->getId()]);
    }

    /**
     * Get edges.
     *
     * @return EdgeInterface[]
     */
    public function getEdges(): array
    {
        if ($this->edges) {

            ksort($this->edges);
        }

        return $this->edges ? array_values($this->edges) : [];
    }

    /**
     * Set edges.
     *
     * @param EdgeInterface[] $edges
     */
    public function setEdges(array $edges): void
    {
        $this->edges = $edges;
    }

    /**
     * Get edge.
     *
     * @param string $id
     *
     * @return EdgeInterface|null
     */
    public function getEdge(string $id): ?EdgeInterface
    {
        if (!array_key_exists($id, $this->edges)) {
            return null;
        }

        return $this->edges[$id];
    }

    /**
     * Add edge.
     *
     * @param EdgeInterface $edge
     *
     * @return EdgeInterface
     */
    public function addEdge(EdgeInterface $edge): EdgeInterface
    {
        $this->edges[(string) $edge] = $edge;

        return $edge;
    }

    /**
     * Remove edge.
     *
     * @param EdgeInterface $edge
     */
    public function removeEdge(EdgeInterface $edge): void
    {
        unset($this->edges[(string) $edge]);
    }
}


1			<?php
2
3			/*
4			* This file is part of the doctrineviz package
5			*
6			* Copyright (c) 2017 Pierre Hennequart
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*
11			* Feel free to edit as you please, and have fun.
12			*
13			* @author Pierre Hennequart <[email protected]>
14			*/
15
16			declare(strict_types=1);
17
18			namespace Janalis\Doctrineviz\Graphviz;
19
20			class Graph implements GraphInterface
21			{
22			use Attributable;
23
24			/** @var VertexInterface[] */
25			protected $vertices;
26
27			/** @var EdgeInterface[] */
28			protected $edges;
29
30			/**
31			* @return string
32			*/
33			public function __toString()
34			{
35			return 'digraph g {'.PHP_EOL.(!count($this->getAttributes()) ? '' : implode(PHP_EOL, $this->indentAll($this->getAttributes())).
36			PHP_EOL).(!count($this->getVertices()) ? '' : implode(PHP_EOL, $this->indentAll($this->getVertices())).
37			PHP_EOL).(!count($this->getEdges()) ? '' : implode(PHP_EOL, $this->indentAll($this->getEdges())).
38			PHP_EOL).'}';
39			}
40
41			/**
42			* Create vertex.
43			*
44			* @param string $id
45			*
46			* @return VertexInterface
47			*/
48			public function createVertex(string $id): VertexInterface
49			{
50			return new Vertex($id, $this);
51			}
52
53			/**
54			* Get vertices.
55			*
56			* @return VertexInterface[]
57			*/
58			public function getVertices(): array
59			{
60			if ($this->vertices) {
			0 ignored issues – show Bug Best Practice introduced 2017-08-24 16:24 UTC by Report Bug Copy Issue Report The expression `$this->vertices` of type `Janalis\Doctrineviz\Graphviz\VertexInterface[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
61			ksort($this->vertices);
62			}
63
64			return $this->vertices ? array_values($this->vertices) : [];
65			}
66
67			/**
68			* Set vertices.
69			*
70			* @param VertexInterface[] $vertices
71			*/
72			public function setVertices(array $vertices): void
73			{
74			foreach ($vertices as $vertex) {
75			$this->addVertex($vertex);
76			}
77			}
78
79			/**
80			* Get vertex.
81			*
82			* @param string $id
83			*
84			* @return VertexInterface
85			*/
86			public function getVertex(string $id): ?VertexInterface
87			{
88			if (!array_key_exists($id, $this->vertices)) {
89			return null;
90			}
91
92			return $this->vertices[$id];
93			}
94
95			/**
96			* Add vertex.
97			*
98			* @param VertexInterface $vertex
99			*/
100			public function addVertex(VertexInterface $vertex): void
101			{
102			$vertex->setGraph($this);
103			$this->vertices[$vertex->getId()] = $vertex;
104			}
105
106			/**
107			* Remove vertex.
108			*
109			* @param VertexInterface $vertex
110			*/
111			public function removeVertex(VertexInterface $vertex): void
112			{
113			unset($this->vertices[$vertex->getId()]);
114			}
115
116			/**
117			* Get edges.
118			*
119			* @return EdgeInterface[]
120			*/
121			public function getEdges(): array
122			{
123			if ($this->edges) {
			0 ignored issues – show Bug Best Practice introduced 2017-08-24 16:24 UTC by Report Bug Copy Issue Report The expression `$this->edges` of type `Janalis\Doctrineviz\Graphviz\EdgeInterface[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
124			ksort($this->edges);
125			}
126
127			return $this->edges ? array_values($this->edges) : [];
128			}
129
130			/**
131			* Set edges.
132			*
133			* @param EdgeInterface[] $edges
134			*/
135			public function setEdges(array $edges): void
136			{
137			$this->edges = $edges;
138			}
139
140			/**
141			* Get edge.
142			*
143			* @param string $id
144			*
145			* @return EdgeInterface\|null
146			*/
147			public function getEdge(string $id): ?EdgeInterface
148			{
149			if (!array_key_exists($id, $this->edges)) {
150			return null;
151			}
152
153			return $this->edges[$id];
154			}
155
156			/**
157			* Add edge.
158			*
159			* @param EdgeInterface $edge
160			*
161			* @return EdgeInterface
162			*/
163			public function addEdge(EdgeInterface $edge): EdgeInterface
164			{
165			$this->edges[(string) $edge] = $edge;
166
167			return $edge;
168			}
169
170			/**
171			* Remove edge.
172			*
173			* @param EdgeInterface $edge
174			*/
175			public function removeEdge(EdgeInterface $edge): void
176			{
177			unset($this->edges[(string) $edge]);
178			}
179			}
180

janalis / doctrineviz

Graph::setEdges() A last analyzed 2021-02-24 09:45 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Graph::setEdges() A
last analyzed 2021-02-24 09:45 UTC