Implemented inNotOutEdges/Neighbors and associated tests for completeness with outNotInEdges/Neighbors

Author: brghash

include/CXXGraph/Graph/Graph_decl.h

@@ -375,14 +375,13 @@ class Graph {
       const std::string &nodeUserId) const;
 
   /**
-   * @brief This function generates a list of adjacency matrix with every element
-   * of the matrix contain the node where is directed the link and the Edge
-   * corrispondent to the link
-   * Note: No Thread Safe
+   * @brief This function generates a list of adjacency matrix with every
+   * element of the matrix contain the node where is directed the link and the
+   * Edge corrispondent to the link Note: No Thread Safe
    */
   virtual shared<AdjacencyMatrix<T>> getAdjMatrixOut() const;
 
-   /**
+  /**
    * @brief This function generate a list of adjacency matrix with every element
    * of the matrix contain the node where is the origin of the Edge and the Edge
    * corrispondent to the link
@@ -437,8 +436,8 @@ class Graph {
   virtual void cacheTransitionMatrix();
 
   /**
-   * \brief This function generates a set of nodes linked only out (not in) from the provided node
-   * in a directed graph
+   * \brief This function generates a set of nodes linked only out (not in) from
+   * the provided node in a directed graph
    *
    * @param Pointer to the node
    *
@@ -447,15 +446,35 @@ class Graph {
   outNotInNeighbors(const Node<T> *node) const;
 
   /**
-   * \brief This function generates a set of nodes linked only out (not in) from the provided node
-   * in a directed graph
+   * \brief This function generates a set of nodes linked only out (not in) from
+   * the provided node in a directed graph
    *
    * @param Pointer to the node
    *
    */
   virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
   outNotInNeighbors(shared<const Node<T>> node) const;
 
+  /**
+   * \brief This function generates a set of nodes linked only in (not out) of
+   * the provided node in a directed graph
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+  inNotOutNeighbors(const Node<T> *node) const;
+
+  /**
+   * \brief This function generates a set of nodes linked only in (not out) of
+   * the provided node in a directed graph
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+  inNotOutNeighbors(shared<const Node<T>> node) const;
+
   /**
    * \brief This function generates a set of nodes linked to the provided node
    * in any graph
@@ -479,24 +498,45 @@ class Graph {
 
   /**
    * \brief
-   * \brief This function generates a set of directed Edges going only out of (not in) to a node 
-   * in any graph
+   * \brief This function generates a set of directed Edges going only out of
+   * (not in) to a node in any graph
    *
    * @param Pointer to the node
    *
    */
-  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>> outNotInEdges(
-      const Node<T> *node) const;
+  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+  outNotInEdges(const Node<T> *node) const;
 
   /**
-   * \brief This function generates a set of directed Edges going only out of (not in) to a node 
-   * in any graph
+   * \brief This function generates a set of directed Edges going only out of
+   * (not in) to a node in any graph
+   *
+   * @param Shared pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+  outNotInEdges(shared<const Node<T>> node) const;
+
+  /**
+   * \brief
+   * \brief This function generates a set of directed Edges going only out of
+   * (not in) to a node in any graph
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+  inNotOutEdges(const Node<T> *node) const;
+
+  /**
+   * \brief This function generates a set of directed Edges going only out of
+   * (not in) to a node in any graph
    *
    * @param Shared pointer to the node
    *
    */
-  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>> outNotInEdges(
-      shared<const Node<T>> node) const;
+  virtual const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+  inNotOutEdges(shared<const Node<T>> node) const;
 
   /**
    * \brief

include/CXXGraph/Graph/Graph_impl.hpp

@@ -701,6 +701,32 @@ Graph<T>::outNotInNeighbors(shared<const Node<T>> node) const {
   return outNotInNeighbors;
 }
 
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+Graph<T>::inNotOutNeighbors(const Node<T> *node) const {
+  auto node_shared = make_shared<const Node<T>>(*node);
+
+  return inNotOutNeighbors(node_shared);
+}
+
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+Graph<T>::inNotOutNeighbors(shared<const Node<T>> node) const {
+  if (cachedAdjMatrixIn->find(node) == cachedAdjMatrixIn->end()) {
+    return std::unordered_set<shared<const Node<T>>, nodeHash<T>>();
+  }
+  auto nodeEdgePairsIn = cachedAdjMatrixIn->at(node);
+
+  std::unordered_set<shared<const Node<T>>, nodeHash<T>> inNotOutNeighbors;
+  for (auto pair : nodeEdgePairsIn) {
+    if (pair.second->isDirected().value_or(false)) {
+      inNotOutNeighbors.insert(pair.first);
+    }
+  }
+
+  return inNotOutNeighbors;
+}
+
 template <typename T>
 const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
 Graph<T>::inOrOutNeighbors(const Node<T> *node) const {
@@ -760,6 +786,32 @@ Graph<T>::outNotInEdges(shared<const Node<T>> node) const {
   return outNotInEdges;
 }
 
+template <typename T>
+const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+Graph<T>::inNotOutEdges(const Node<T> *node) const {
+  auto node_shared = make_shared<const Node<T>>(*node);
+
+  return inNotOutEdges(node_shared);
+}
+
+template <typename T>
+const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
+Graph<T>::inNotOutEdges(shared<const Node<T>> node) const {
+  if (cachedAdjMatrixIn->find(node) == cachedAdjMatrixIn->end()) {
+    return std::unordered_set<shared<const Edge<T>>, edgeHash<T>>();
+  }
+  auto nodeEdgePairsIn = cachedAdjMatrixIn->at(node);
+
+  std::unordered_set<shared<const Edge<T>>, edgeHash<T>> inNotOutEdges;
+  for (auto pair : nodeEdgePairsIn) {
+    if (pair.second->isDirected().value_or(false)) {
+      inNotOutEdges.insert(pair.second);
+    }
+  }
+
+  return inNotOutEdges;
+}
+
 template <typename T>
 const std::unordered_set<shared<const Edge<T>>, edgeHash<T>>
 Graph<T>::inOrOutEdges(const Node<T> *node) const {

test/DirectedEdgeTest.cpp

@@ -166,6 +166,10 @@ TEST(DirectedEdgeTest, inOutNeigbors_1) {
   ASSERT_EQ(g.outNotInNeighbors(&n2).size(), 1);
   ASSERT_EQ(g.outNotInNeighbors(&n3).size(), 0);
 
+  ASSERT_EQ(g.inNotOutNeighbors(&n1).size(), 0);
+  ASSERT_EQ(g.inNotOutNeighbors(&n2).size(), 1);
+  ASSERT_EQ(g.inNotOutNeighbors(&n3).size(), 1);
+
   ASSERT_EQ(g.inOrOutNeighbors(&n1).size(), 1);
   ASSERT_EQ(g.inOrOutNeighbors(&n2).size(), 2);
   ASSERT_EQ(g.inOrOutNeighbors(&n3).size(), 1);  
@@ -174,6 +178,10 @@ TEST(DirectedEdgeTest, inOutNeigbors_1) {
   ASSERT_EQ(g.outNotInEdges(&n2).size(), 1);
   ASSERT_EQ(g.outNotInEdges(&n3).size(), 0);
 
+  ASSERT_EQ(g.inNotOutEdges(&n1).size(), 0);
+  ASSERT_EQ(g.inNotOutEdges(&n2).size(), 1);
+  ASSERT_EQ(g.inNotOutEdges(&n3).size(), 1);
+
   ASSERT_EQ(g.inOrOutEdges(&n1).size(), 1);
   ASSERT_EQ(g.inOrOutEdges(&n2).size(), 2);
   ASSERT_EQ(g.inOrOutEdges(&n3).size(), 1);