AssociationGraphObserver.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_GRAPH_ASSOCIATIONGRAPHOBSERVER_H
#define BPP_GRAPH_ASSOCIATIONGRAPHOBSERVER_H

#include <iostream>
#include <map>
#include <memory>
#include <ostream>
#include <type_traits>
#include <vector>

#include "../Clonable.h"
#include "../Exceptions.h"
#include "GraphObserver.h"

namespace bpp
{
template<class N, class E>
class AssociationGraphObserver :
  public virtual GraphObserver
{
private:
  typedef Graph::NodeId NodeGraphid;
  typedef Graph::EdgeId EdgeGraphid;

public:
  typedef unsigned int NodeIndex;
  typedef unsigned int EdgeIndex;

  template<class A, class B>
  static B* copy(const A& a, typename std::enable_if< !std::is_base_of<B, A>::value && !std::is_abstract<B>::value, B*>::type* = 0)
  {
    return new B(a);
  }

  template<class A, class B>
  static B* copy(const A& a, typename std::enable_if< !std::is_base_of<B, A>::value && std::is_abstract<B>::value, B*>::type* = 0)
  {
    throw Exception("Unknow AssociationGraphObserver::copy(const A& a, typename std::enable_if< !std::is_base_of<B, A>::value&& std::is_abstract<B>::value, B*>::type* = 0)");
    return 0;
  }

  template<class A, class B>
  static B* copy(const A& a, typename std::enable_if< std::is_base_of<B, A>::value && !std::is_abstract<A>::value, B*>::type* = 0)
  {
    return dynamic_cast<B*>(new A(a));
  }

  template<class A, class B>
  static B* copy(const A& a, typename std::enable_if< std::is_base_of<B, A>::value && std::is_abstract<A>::value && std::is_base_of<Clonable, A>::value, B*>::type* = 0)
  {
    return dynamic_cast<B*>(a.clone());
  }

  template<class A, class B>
  static B* copy(const A& a, typename std::enable_if< std::is_base_of<B, A>::value && std::is_abstract<A>::value && !std::is_base_of<Clonable, A>::value, B*>::type* = 0)
  {
    throw Exception("Unknow AssociationGraphObserver::copy(const A& a, typename std::enable_if< std::is_base_of<B, A>::value&& std::is_abstract<A>::value && !std::is_base_of<Clonable, A>::value, B*>::type*= 0)");
    return 0;
  }


  // /@{

  virtual void createNode(std::shared_ptr<N>  newNodeObject) = 0;


  virtual void createNode(std::shared_ptr<N>  objectOriginNode, std::shared_ptr<N>  newNodeObject, std::shared_ptr<E>  newEdgeObject = 00) = 0;

  virtual void link(std::shared_ptr<N>  nodeObjectA, std::shared_ptr<N>  nodeObjectB, std::shared_ptr<E>  edgeObject = 00) = 0;

  virtual void unlink(std::shared_ptr<N>  nodeObjectA, std::shared_ptr<N>  nodeObjectB) = 0;

  virtual void deleteNode(std::shared_ptr<N>  nodeObject) = 0;

  // /@}

  // /@{

  virtual void associateNode(std::shared_ptr<N>  nodeObject, NodeGraphid node) = 0;

  virtual void associateEdge(std::shared_ptr<E>  edgeObject, EdgeGraphid edge) = 0;

  virtual void dissociateNode(std::shared_ptr<N>  nodeObject) = 0;
  virtual void dissociateEdge(std::shared_ptr<E>  edgeObject) = 0;


  virtual NodeGraphid getNodeGraphid(const std::shared_ptr<N>  nodeObject) const = 0;

  virtual EdgeGraphid getEdgeGraphid(const std::shared_ptr<E>  edgeObject) const = 0;

  virtual const std::shared_ptr<N>  getNodeFromGraphid(NodeGraphid) const = 0;
  virtual std::shared_ptr<N>  getNodeFromGraphid(NodeGraphid) = 0;

  virtual std::vector<std::shared_ptr<N>> getNodesFromGraphid(std::vector<NodeGraphid> ) const = 0;
  virtual std::shared_ptr<E>  getEdgeFromGraphid(EdgeGraphid) = 0;
  virtual const std::shared_ptr<E>  getEdgeFromGraphid(EdgeGraphid) const = 0;
  virtual std::vector<std::shared_ptr<E>> getEdgesFromGraphid(std::vector<EdgeGraphid> ) const = 0;


  virtual std::shared_ptr<N> getRoot() const = 0;

  virtual NodeIndex getRootIndex() const = 0;

  // /@}


  // /@{

  virtual bool hasNodeIndex(const std::shared_ptr<N> nodeObject) const = 0;
  virtual bool hasEdgeIndex(const std::shared_ptr<E> edgeObject) const = 0;

  virtual NodeIndex getNodeIndex(const std::shared_ptr<N>  nodeObject) const = 0;
  virtual std::vector<NodeIndex> getNodeIndexes(std::vector<std::shared_ptr<N>> nodeObjects) const = 0;


  virtual EdgeIndex getEdgeIndex(const std::shared_ptr<E>  edgeObject) const = 0;
  virtual std::vector<EdgeIndex> getEdgeIndexes(std::vector<std::shared_ptr<E>> edgeObjects) const = 0;

  virtual NodeIndex setNodeIndex(const std::shared_ptr<N>  nodeObject, NodeIndex index) = 0;

  virtual EdgeIndex setEdgeIndex(const std::shared_ptr<E>  edgeObject, EdgeIndex index) = 0;

  virtual bool hasNode(NodeIndex nodeIndex) const = 0;

  virtual bool hasEdge(EdgeIndex edgeIndex) const = 0;

  virtual std::shared_ptr<N> getNode(NodeIndex nodeIndex) const = 0;

  virtual std::shared_ptr<E> getEdge(EdgeIndex edgeIndex) const = 0;

  // /@}

  // /@{

  class NodeIterator
  {
public:
    virtual ~NodeIterator() {}

    virtual void next() = 0;
    virtual bool end() const = 0;
    virtual void start() = 0;

    virtual std::shared_ptr<N> operator*() = 0;
  };


  /*
   * @brief builds iterator on all Nodes of the graph
   *
   */

  virtual std::unique_ptr<NodeIterator> allNodesIterator() = 0;

  virtual std::unique_ptr<NodeIterator> allNodesIterator() const = 0;

  /*
   * @brief builds iterator on the outgoing neighbor nodes of a Node
   *
   */

  virtual std::unique_ptr<NodeIterator> outgoingNeighborNodesIterator(std::shared_ptr<N> node) = 0;

  virtual std::unique_ptr<NodeIterator> outgoingNeighborNodesIterator(std::shared_ptr<N> node) const = 0;

  /*
   * @brief builds iterator on the incoming neighbor nodes of a Node
   *
   */

  virtual std::unique_ptr<NodeIterator> incomingNeighborNodesIterator(std::shared_ptr<N> node) = 0;

  virtual std::unique_ptr<NodeIterator> incomingNeighborNodesIterator(std::shared_ptr<N> node) const = 0;

  virtual std::vector<std::shared_ptr<N>> getNeighbors(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<NodeIndex> getNeighbors(NodeIndex node) const = 0;

  virtual std::vector<std::shared_ptr<E>> getEdges(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<EdgeIndex> getEdges(NodeIndex node) const = 0;

  virtual std::vector<std::shared_ptr<N>> getOutgoingNeighbors(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<NodeIndex> getOutgoingNeighbors(NodeIndex node) const = 0;

  virtual std::vector<std::shared_ptr<E>> getOutgoingEdges(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<EdgeIndex> getOutgoingEdges(NodeIndex node) const = 0;


  virtual std::vector<std::shared_ptr<N>> getIncomingNeighbors(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<NodeIndex> getIncomingNeighbors(NodeIndex node) const = 0;

  virtual std::vector<std::shared_ptr<E>> getIncomingEdges(const std::shared_ptr<N>  node) const = 0;
  virtual std::vector<EdgeIndex> getIncomingEdges(NodeIndex node) const = 0;


  virtual std::vector<std::shared_ptr<N>> getLeavesFromNode(std::shared_ptr<N>  node, unsigned int maxDepth) const = 0;

  virtual std::vector<std::shared_ptr<N>> getAllLeaves() const = 0;
  virtual std::vector<NodeIndex> getAllLeavesIndexes() const = 0;

  virtual std::vector<std::shared_ptr<N>> getAllInnerNodes() const = 0;
  virtual std::vector<NodeIndex> getAllInnerNodesIndexes() const = 0;

  virtual std::vector<std::shared_ptr<N>> getAllNodes() const = 0;
  virtual std::vector<NodeIndex> getAllNodesIndexes() const = 0;

  class EdgeIterator
  {
public:
    virtual ~EdgeIterator() {}

    virtual void next() = 0;
    virtual bool end() const = 0;
    virtual void start() = 0;

    virtual std::shared_ptr<E> operator*() = 0;
  };


  /*
   * @brief builds iterator on all Nodes of the graph
   *
   */

  virtual std::unique_ptr<EdgeIterator> allEdgesIterator() = 0;

  /*
   * @brief builds iterator on the outgoing neighbor nodes of a Node
   *
   */

  virtual std::unique_ptr<EdgeIterator> outgoingEdgesIterator(std::shared_ptr<N> node) = 0;

  /*
   * @brief builds iterator on the incoming neighbor nodes of a Node
   *
   */

  virtual std::unique_ptr<EdgeIterator> incomingEdgesIterator(std::shared_ptr<N> node) = 0;

  virtual std::vector<std::shared_ptr<E>> getAllEdges() const = 0;
  virtual std::vector<EdgeIndex> getAllEdgesIndexes() const = 0;


  virtual std::shared_ptr<E>  getEdgeLinking(std::shared_ptr<N>  nodeA, std::shared_ptr<N>  nodeB) const = 0;

  virtual void setEdgeLinking(std::shared_ptr<N>  nodeA, std::shared_ptr<N>  nodeB, std::shared_ptr<E>  edge) = 0;

  // /@}
};
}
#endif // BPP_GRAPH_ASSOCIATIONGRAPHOBSERVER_H