AssociationDAGraphImplObserver.h

Go to the documentation of this file.

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

#ifndef BPP_GRAPH_ASSOCIATIONDAGRAPHIMPLOBSERVER_H
#define BPP_GRAPH_ASSOCIATIONDAGRAPHIMPLOBSERVER_H

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

#include "AssociationDAGraphObserver.h"
#include "AssociationGraphImplObserver.h"
#include "DAGraphImpl.h"

namespace bpp
{
template<class N, class E, class DAGraphImpl>
class AssociationDAGraphImplObserver :
  public AssociationDAGraphObserver<N, E>,
  public AssociationGraphImplObserver<N, E, DAGraphImpl>
{
public:
  typedef typename AssociationGraphObserver<N, E>::NodeIndex NodeIndex;
  typedef typename AssociationGraphObserver<N, E>::EdgeIndex EdgeIndex;

  typedef typename Graph::NodeId NodeGraphid;
  typedef typename Graph::EdgeId EdgeGraphid;

public:
  AssociationDAGraphImplObserver() :
    AssociationGraphImplObserver<N, E, DAGraphImpl>(true)
  {}

  AssociationDAGraphImplObserver(std::shared_ptr<DAGraphImpl> subjectDAGraph) :
    AssociationGraphImplObserver<N, E, DAGraphImpl>(subjectDAGraph)
  {}

  AssociationDAGraphImplObserver(bpp::AssociationDAGraphImplObserver<N, E, DAGraphImpl> const& dAGraphObserver) :
    AssociationGraphImplObserver<N, E, DAGraphImpl>(dAGraphObserver)
  {}


  template<class N2, class E2>
  AssociationDAGraphImplObserver(bpp::AssociationDAGraphImplObserver<N2, E2, DAGraphImpl> const& dAGraphObserver) :
    AssociationGraphImplObserver<N, E, DAGraphImpl>(dAGraphObserver)
  {}

  AssociationDAGraphImplObserver<N, E, DAGraphImpl>& operator=(bpp::AssociationDAGraphImplObserver<N, E, DAGraphImpl> const& dAGraphObserver)
  {
    AssociationGraphImplObserver<N, E, DAGraphImpl>::operator=(dAGraphObserver);
    return *this;
  }

  ~AssociationDAGraphImplObserver()
  {}

  AssociationDAGraphImplObserver<N, E, DAGraphImpl>* clone() const
  {
    return new AssociationDAGraphImplObserver<N, E, DAGraphImpl>(*this);
  }


  bool isValid() const
  {
    return this->getGraph()->isValid();
  }

  bool isRooted() const
  {
    return this->getGraph()->isRooted();
  }


  std::vector<std::shared_ptr<N>> getFathers(const std::shared_ptr<N>  node) const
  {
    return this->getNodesFromGraphid(this->getGraph()->getFathers(this->getNodeGraphid(node)));
  }

  std::vector<NodeIndex> getFathers(const NodeIndex node) const
  {
    return this->getNodeIndexes(this->getNodesFromGraphid(this->getGraph()->getFathers(this->getNodeGraphid(this->getNode(node)))));
  }

  void rootAt(const std::shared_ptr<N> root)
  {
    this->getGraph()->rootAt(this->getNodeGraphid(root));
  }

  bool hasFather(const std::shared_ptr<N> nodeObject) const
  {
    return this->getGraph()->hasFather(this->getNodeGraphid(nodeObject));
  }

  bool hasFather(const NodeIndex node) const
  {
    return this->getGraph()->hasFather(this->getNodeGraphid(this->getNode(node)));
  }

  std::vector<std::shared_ptr<N>> getSons(const std::shared_ptr<N> node) const
  {
    return this->getNodesFromGraphid(this->getGraph()->getSons(this->getNodeGraphid(node)));
  }

  std::vector<NodeIndex> getSons(const NodeIndex node) const
  {
    return this->getNodeIndexes(this->getNodesFromGraphid(this->getGraph()->getSons(this->getNodeGraphid(this->getNode(node)))));
  }


  std::shared_ptr<N> getSon(const std::shared_ptr<E>  edge) const
  {
    return this->getNodeFromGraphid(this->getGraph()->getBottom(this->getEdgeGraphid(edge)));
  }

  NodeIndex getSon(const EdgeIndex edgeId) const
  {
    return this->getNodeIndex(this->getNodeFromGraphid(this->getGraph()->getBottom(this->getEdgeGraphid(this->getEdge(edgeId)))));
  }


  std::shared_ptr<N> getFatherOfEdge(const std::shared_ptr<E>  edge) const
  {
    return this->getNodeFromGraphid(this->getGraph()->getTop(this->getEdgeGraphid(edge)));
  }

  NodeIndex getFatherOfEdge(const EdgeIndex edge) const
  {
    return this->getNodeIndex(this->getNodeFromGraphid(this->getGraph()->getTop(this->getEdgeGraphid(this->getEdge(edge)))));
  }

  size_t getNumberOfFathers(const std::shared_ptr<N>  node) const
  {
    return this->getGraph()->getNumberOfFathers(this->getNodeGraphid(node));
  }

  size_t getNumberOfSons(const std::shared_ptr<N>  node) const
  {
    return this->getGraph()->getNumberOfSons(this->getNodeGraphid(node));
  }

  std::vector<std::shared_ptr<N>> getLeavesUnderNode(std::shared_ptr<N>  node) const
  {
    return this->getNodesFromGraphid(this->getGraph()->getLeavesUnderNode(this->getNodeGraphid(node)));
  }

  std::vector<std::shared_ptr<N>> removeFathers(const std::shared_ptr<N>  node)
  {
    return this->getNodesFromGraphid(this->getGraph()->removeFathers(this->getNodeGraphid(node)));
  }

  void removeFather(const std::shared_ptr<N> node, const std::shared_ptr<N> father)
  {
    this->getGraph()->removeFather(this->getNodeGraphid(node), this->getNodeGraphid(father));
  }

  std::vector<std::shared_ptr<N>> removeSons(const std::shared_ptr<N>  node)
  {
    return this->getNodesFromGraphid(this->getGraph()->removeSons(this->getNodeGraphid(node)));
  }

  void removeSon(const std::shared_ptr<N> node, const std::shared_ptr<N> son)
  {
    this->getGraph()->removeSon(this->getNodeGraphid(node), this->getNodeGraphid(son));
  }

  void addFather(const std::shared_ptr<N> nodeObject, const std::shared_ptr<N>  fatherNodeObject, const std::shared_ptr<E> edgeObject = 0)
  {
    if (edgeObject)
      try
      {
        this->getGraph()->addFather(this->getNodeGraphid(nodeObject), this->getNodeGraphid(fatherNodeObject), this->getEdgeGraphid(edgeObject));
      }
      catch (Exception& e)
      {
        this->link(fatherNodeObject, nodeObject, edgeObject);
      }
    else
      this->getGraph()->addFather(this->getNodeGraphid(nodeObject), this->getNodeGraphid(fatherNodeObject));
  }

  void addSon(const std::shared_ptr<N> nodeObject, const std::shared_ptr<N> sonNodeObject, const std::shared_ptr<E> edgeObject = 0)
  {
    if (edgeObject)
      try
      {
        this->getGraph()->addSon(this->getNodeGraphid(nodeObject), this->getNodeGraphid(sonNodeObject), this->getEdgeGraphid(edgeObject));
      }
      catch (Exception& e)
      {
        this->link(nodeObject, sonNodeObject, edgeObject);
      }
    else
      this->getGraph()->addSon(this->getNodeGraphid(nodeObject), this->getNodeGraphid(sonNodeObject));
  }

  /*
   * @brief builds iterator on the fathers of a Node
   *
   */
  std::unique_ptr<typename AssociationDAGraphObserver<N, E>::NodeIterator> fathersIterator(std::shared_ptr<N> node)
  {
    return this->incomingNeighborNodesIterator(node);
  }

  std::unique_ptr<typename AssociationDAGraphObserver<N, E>::NodeIterator> fathersIterator(std::shared_ptr<N> node) const
  {
    return this->incomingNeighborNodesIterator(node);
  }

  /*
   * @brief builds iterator on the sons of a Node
   *
   */
  std::unique_ptr<typename AssociationDAGraphObserver<N, E>::NodeIterator> sonsIterator(std::shared_ptr<N> node)
  {
    return this->outgoingNeighborNodesIterator(node);
  }

  std::unique_ptr<typename AssociationDAGraphObserver<N, E>::NodeIterator> sonsIterator(std::shared_ptr<N> node) const
  {
    return this->outgoingNeighborNodesIterator(node);
  }

  std::vector<std::shared_ptr<N>> getBelowNodes(const std::shared_ptr<N> localRoot)
  {
    return this->getNodesFromGraphid(this->getGraph()->getBelowNodes(this->getNodeGraphid(localRoot)));
  }

  std::vector<std::shared_ptr<E>> getBelowEdges(const std::shared_ptr<N> localRoot)
  {
    return AssociationGraphImplObserver<N, E, DAGraphImpl>::getEdgesFromGraphid(this->getGraph()->getBelowEdges(this->getNodeGraphid(localRoot)));
  }
};

/********************/

template<class N, class E>
using AssociationDAGlobalGraphObserver =  AssociationDAGraphImplObserver<N, E, DAGlobalGraph>;

/********************/
}
#endif // BPP_GRAPH_ASSOCIATIONDAGRAPHIMPLOBSERVER_H