some minor improvements

Author: doganoo

src/Algorithm/Search/BreadthFirstSearch.php

@@ -55,6 +55,7 @@ public function search(AbstractGraph $graph) {
      * @return mixed|void
      */
     public function searchByNode(?Node $node) {
+        if (null === $node) return;
         $queue = new Queue();
         $this->visited->add($node);
         $queue->enqueue($node);

src/Common/Abstracts/AbstractGraph.php

@@ -66,16 +66,34 @@ public function getRoot(): ?Node {
             ? null : $this->nodeList->get(0);
     }
 
+    /**
+     * @param $value
+     * @return bool
+     */
+    public function createNode($value): bool {
+        $node = new Node($value);
+        return $this->addNode($node);
+    }
+
     /**
      * @param Node $node
      * @return bool
      */
-    public abstract function addNode(Node $node): bool;
+    public function addNode(Node $node): bool {
+        return $this->nodeList->add($node);
+    }
 
     /**
      * @param Node $startNode
      * @param Node $endNode
      * @return bool
      */
     public abstract function addEdge(Node $startNode, Node $endNode): bool;
+
+    /**
+     * @return ArrayList|null
+     */
+    public function getNodes(): ?ArrayList {
+        return $this->nodeList;
+    }
 }

src/Common/Abstracts/AbstractGraphSearch.php

@@ -42,8 +42,9 @@ abstract class AbstractGraphSearch {
 
     public function __construct() {
         $this->visited = new ArrayList();
-        $this->callable = function ($value) {
-            echo $value;
+        $this->callable = function (Node $value) {
+            echo $value->getValue();
+            echo "\n";
         };
     }
 
@@ -56,12 +57,13 @@ public abstract function search(AbstractGraph $graph);
     /**
      * @param $value
      */
-    public function visit($value) {
+    public function visit(Node $value) {
         $callable = $this->callable;
         if (null === $this->callable
             && !\is_callable($this->callable)) {
-            $callable = function ($otherValue) {
-                echo $otherValue;
+            $callable = function (Node $otherValue) {
+                echo $otherValue->getValue();
+                echo "\n";
             };
         }
         $callable($value);

src/Common/Exception/NodeNotFoundException.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * MIT License
+ *
+ * Copyright (c) 2018 Dogan Ucar
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+namespace doganoo\PHPAlgorithms\Common\Exception;
+
+/**
+ * Class NodeNotFoundException
+ *
+ * @package doganoo\PHPAlgorithms\Common\Exception
+ */
+class NodeNotFoundException extends \Exception {
+
+}

src/Common/Util/Comparator.php

@@ -89,6 +89,30 @@ public static function lessThan($that, $other): bool {
         return $that < $other;
     }
 
+    /**
+     * @param $that
+     * @param $other
+     * @return bool
+     */
+    public static function lessThanEqual($that, $other): bool {
+        if ($that instanceof Comparable) {
+            return $that->compareTo($other) == -1;
+        }
+        if (\is_object($that)) {
+            if (\is_object($other)) {
+                return $that <= $other;
+            }
+            return false;
+        }
+        if (\is_object($other)) {
+            if (\is_object($that)) {
+                return $other <= $that;
+            }
+            return false;
+        }
+        return $that <= $other;
+    }
+
     /**
      * @param $that
      * @param $other
@@ -110,7 +134,31 @@ public static function greaterThan($that, $other): bool {
             }
             return false;
         }
-        return ($that > $other);
+        return $that > $other;
+    }
+
+    /**
+     * @param $that
+     * @param $other
+     * @return bool
+     */
+    public static function greaterThanEqual($that, $other): bool {
+        if ($that instanceof Comparable) {
+            return $that->compareTo($other) == 1;
+        }
+        if (\is_object($that)) {
+            if (\is_object($other)) {
+                return $that >= $other;
+            }
+            return false;
+        }
+        if (\is_object($other)) {
+            if (\is_object($that)) {
+                return $other >= $that;
+            }
+            return false;
+        }
+        return $that >= $other;
     }
 
 }

src/Datastructure/Graph/Graph/DirectedGraph.php

@@ -43,11 +43,6 @@ public function __construct() {
         parent::__construct(self::DIRECTED_GRAPH);
     }
 
-
-    public function addNode(Node $node): bool {
-        return $this->nodeList->add($node);
-    }
-
     /**
      * @param Node $startNode
      * @param Node $endNode
@@ -81,6 +76,7 @@ public function addEdge(Node $startNode, Node $endNode): bool {
             return false;
         }
         $startNode->addAdjacent($endNode);
+        $endNode->incrementInbound();
 
         $this->nodeList->set($indexOfStartNode, $startNode);
         return true;

src/Datastructure/Graph/Graph/Node.php

@@ -27,7 +27,6 @@
 
 use doganoo\PHPAlgorithms\Common\Interfaces\Comparable;
 use doganoo\PHPAlgorithms\Common\Interfaces\INode;
-use doganoo\PHPAlgorithms\Common\Util\Comparator;
 use doganoo\PHPAlgorithms\Datastructure\Lists\ArrayLists\ArrayList;
 
 /**
@@ -36,18 +35,51 @@
  * @package doganoo\PHPAlgorithms\Graph
  */
 class Node implements Comparable, INode {
+    /** @var mixed $value */
     private $value;
+    /** @var ArrayList|null $adjacent */
     private $adjacent = null;
+    /** @var int $inbound */
+    private $inbound = 0;
 
+
+    /**
+     * Node constructor.
+     *
+     * @param $value
+     */
     public function __construct($value) {
         $this->value = $value;
         $this->adjacent = new ArrayList();
+        $this->inbound = 0;
     }
 
+    /**
+     * @param Node $node
+     * @return bool
+     */
     public function addAdjacent(Node $node): bool {
         return $this->adjacent->add($node);
     }
 
+    /**
+     * @return void
+     */
+    public function incrementInbound(): void {
+        $this->inbound++;
+    }
+
+    /**
+     * @return void
+     */
+    public function decrementInbound(): void {
+        $this->inbound--;
+    }
+
+    /**
+     * @param Node $node
+     * @return bool
+     */
     public function hasAdjacent(Node $node) {
         /**
          * @var      $key
@@ -61,16 +93,19 @@ public function hasAdjacent(Node $node) {
         return false;
     }
 
+    /**
+     * @return mixed
+     */
     public function getValue() {
         return $this->value;
     }
 
+    /**
+     * @param Node $node
+     * @return bool
+     */
     public function equals(Node $node): bool {
-        return Comparator::equals($this->value, $node->getValue());
-    }
-
-    public function getAdjacents(): ?ArrayList {
-        return $this->adjacent;
+        return $this->compareTo($node) === 0;
     }
 
     /**
@@ -92,4 +127,18 @@ public function compareTo($object): int {
         }
         return -1;
     }
+
+    /**
+     * @return ArrayList|null
+     */
+    public function getAdjacents(): ?ArrayList {
+        return $this->adjacent;
+    }
+
+    /**
+     * @return int
+     */
+    public function countInbound(): int {
+        return $this->inbound;
+    }
 }

src/Datastructure/Graph/Graph/UndirectedGraph.php

@@ -26,6 +26,7 @@
 namespace doganoo\PHPAlgorithms\Datastructure\Graph\Graph;
 
 use doganoo\PHPAlgorithms\Common\Abstracts\AbstractGraph;
+use doganoo\PHPAlgorithms\Common\Exception\NodeNotFoundException;
 
 /**
  * Class Graph
@@ -43,7 +44,10 @@ public function __construct() {
         parent::__construct(self::UNDIRECTED_GRAPH);
     }
 
-
+    /**
+     * @param Node $node
+     * @return bool
+     */
     public function addNode(Node $node): bool {
         return $this->nodeList->add($node);
     }
@@ -53,17 +57,16 @@ public function addNode(Node $node): bool {
      * @param Node $endNode
      * @return bool
      * @throws \doganoo\PHPAlgorithms\Common\Exception\IndexOutOfBoundsException
+     * @throws NodeNotFoundException
      */
     public function addEdge(Node $startNode, Node $endNode): bool {
         $hasStart = $this->nodeList->containsValue($startNode);
         $hasEnd = $this->nodeList->containsValue($endNode);
         if (false === $hasStart) {
-            //TODO notify caller
-            return false;
+            throw new NodeNotFoundException();
         }
         if (false === $hasEnd) {
-            //TODO notify caller
-            return false;
+            throw new NodeNotFoundException();
         }
         $indexOfStartNode = $this->nodeList->indexOf($startNode);
         /** @var Node $startNode */
@@ -72,11 +75,12 @@ public function addEdge(Node $startNode, Node $endNode): bool {
         /** @var Node $endNode */
         $endNode = $this->nodeList->get($indexOfEndNode);
 
-        if ($startNode->hasAdjacent($endNode)) {
+        if (!$startNode->hasAdjacent($endNode)) {
             //TODO notify caller
             return false;
         }
         $startNode->addAdjacent($endNode);
+        $endNode->incrementInbound();
 
         $this->nodeList->set($indexOfStartNode, $startNode);
         return true;