Node.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_TREE_NODE_H
#define BPP_PHYL_TREE_NODE_H
 
#include <Bpp/BppString.h>
#include <Bpp/Clonable.h>
#include <Bpp/Numeric/Number.h>
#include <Bpp/Utils/MapTools.h>
 
#include "TreeExceptions.h"
 
// From the STL:
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <algorithm>
#include <cstddef>
#include <memory>
 
namespace bpp
{
  class PhyloTree;
  class PhyloNode;
class Node
{
protected:
  int id_;
  std::string* name_;
  std::vector<Node*> sons_;
  Node* father_;
  double* distanceToFather_;
  mutable std::map<std::string, Clonable*> nodeProperties_;
  mutable std::map<std::string, Clonable*> branchProperties_;
 
public:
  Node() :
    id_(0),
    name_(0),
    sons_(),
    father_(0),
    distanceToFather_(0),
    nodeProperties_(),
    branchProperties_()
  {}
 
  Node(int id) :
    id_(id),
    name_(0),
    sons_(),
    father_(0),
    distanceToFather_(0),
    nodeProperties_(),
    branchProperties_()
  {}
 
  Node(const std::string& name) :
    id_(0),
    name_(new std::string(name)),
    sons_(),
    father_(0),
    distanceToFather_(0),
    nodeProperties_(),
    branchProperties_()
  {}
 
  Node(int id, const std::string& name) :
    id_(id),
    name_(new std::string(name)),
    sons_(),
    father_(0),
    distanceToFather_(0),
    nodeProperties_(),
    branchProperties_()
  {}
 
  Node(const Node& node);
 
  Node& operator=(const Node& node);
 
  Node* clone() const { return new Node(*this); }
 
public:
  virtual ~Node()
  {
    if (name_) delete name_;
    if (distanceToFather_) delete distanceToFather_;
    for (std::map<std::string, Clonable*>::iterator i = nodeProperties_.begin(); i != nodeProperties_.end(); i++)
    {
      delete i->second;
    }
    for (std::map<std::string, Clonable*>::iterator i = branchProperties_.begin(); i != branchProperties_.end(); i++)
    {
      delete i->second;
    }
  }
 
public:
  virtual int getId() const { return id_; }
 
  virtual void setId(int id) { id_ = id; }
 
  virtual std::vector<int> getSonsId() const
  {
    std::vector<int> sonsId(sons_.size());
    for (size_t i = 0; i < sons_.size(); i++)
    {
      sonsId[i] = sons_[i]->getId();
    }
    return sonsId;
  }
 
  virtual std::string getName() const
  {
    if (!hasName()) throw NodePException("Node::getName: no name associated to this node.", this);
    return *name_;
  }
 
  virtual void setName(const std::string& name)
  {
    if (name_) delete name_;
    name_ = new std::string(name);
  }
 
  virtual void deleteName()
  {
    if (name_) delete name_;
    name_ = 0;
  }
 
  virtual bool hasName() const { return name_ != 0; }
 
  virtual double getDistanceToFather() const
  {
    if (!hasDistanceToFather())
      throw NodePException("Node::getDistanceToFather: Node has no distance.", this);
    return *distanceToFather_;
  }
 
  virtual void setDistanceToFather(double distance)
  {
    if (distanceToFather_)
      delete distanceToFather_;
    distanceToFather_ = new double(distance);
  }
 
  virtual void deleteDistanceToFather()
  {
    if (distanceToFather_)
      delete distanceToFather_;
    distanceToFather_ = 0;
  }
 
  virtual bool hasDistanceToFather() const
  {
    return distanceToFather_ != 0;
  }
 
  virtual const Node* getFather() const { return father_; }
 
  virtual Node* getFather() { return father_; }
 
  virtual int getFatherId() const { return father_->getId(); }
 
  virtual void setFather(Node* node)
  {
    if (!node)
      throw NullPointerException("Node::setFather(). Empty node given as input.");
    father_ = node;
    if (find(node->sons_.begin(), node->sons_.end(), this) == node->sons_.end())
      node->sons_.push_back(this);
    else // Otherwise node is already present.
      std::cerr << "DEVEL warning: Node::setFather. Son node already registered! No pb here, but could be a bug in your implementation..." << std::endl;
  }
 
  virtual Node* removeFather()
  {
    Node* f = father_;
    father_ = 0;
    return f;
  }
 
  virtual bool hasFather() const { return father_ != 0; }
 
  virtual size_t getNumberOfSons() const { return sons_.size(); }
 
  virtual std::vector<Node*>& getSons()
  {
    return sons_;
  }
 
  virtual const Node* getSon(size_t pos) const
  {
    if (pos >= sons_.size()) throw IndexOutOfBoundsException("Node::getSon().", pos, 0, sons_.size() - 1);
    return sons_[pos];
  }
 
  virtual Node* getSon(size_t pos)
  {
    if (pos >= sons_.size()) throw IndexOutOfBoundsException("Node::getSon().", pos, 0, sons_.size() - 1);
    return sons_[pos];
  }
 
  virtual void addSon(size_t pos, Node* node)
  {
    if (!node)
      throw NullPointerException("Node::addSon(). Empty node given as input.");
    if (find(sons_.begin(), sons_.end(), node) == sons_.end())
      sons_.insert(sons_.begin() + static_cast<ptrdiff_t>(pos), node);
    else // Otherwise node is already present.
      std::cerr << "DEVEL warning: Node::addSon. Son node already registered! No pb here, but could be a bug in your implementation..." << std::endl;
 
    node->father_ = this;
  }
 
  virtual void addSon(Node* node)
  {
    if (!node)
      throw NullPointerException("Node::addSon(). Empty node given as input.");
    if (find(sons_.begin(), sons_.end(), node) == sons_.end())
      sons_.push_back(node);
    else // Otherwise node is already present.
      throw NodePException("Node::addSon. Trying to add a node which is already present.");
    node->father_ = this;
  }
 
  virtual void setSon(size_t pos, Node* node)
  {
    if (!node)
      throw NullPointerException("Node::setSon(). Empty node given as input.");
    if (pos >= sons_.size())
      throw IndexOutOfBoundsException("Node::setSon(). Invalid node position.", pos, 0, sons_.size() - 1);
    std::vector<Node*>::iterator search = find(sons_.begin(), sons_.end(), node);
    if (search == sons_.end() || search == sons_.begin() + static_cast<ptrdiff_t>(pos))
      sons_[pos] = node;
    else
      throw NodePException("Node::setSon. Trying to set a node which is already present.");
    node->father_ = this;
  }
 
  virtual Node* removeSon(size_t pos)
  {
    if (pos >= sons_.size())
      throw IndexOutOfBoundsException("Node::removeSon(). Invalid node position.", pos, 0, sons_.size() - 1);
    Node* node = sons_[pos];
    sons_.erase(sons_.begin() + static_cast<ptrdiff_t>(pos));
    node->removeFather();
    return node;
  }
 
  virtual void removeSon(Node* node)
  {
    if (!node)
      throw NullPointerException("Node::removeSon(). Empty node given as input.");
    for (size_t i = 0; i < sons_.size(); i++)
    {
      if (sons_[i] == node)
      {
        sons_.erase(sons_.begin() + static_cast<ptrdiff_t>(i));
        node->removeFather();
        return;
      }
    }
    throw NodeNotFoundException("Node::removeSon.", node->getId());
  }
 
  virtual void removeSons()
  {
    while (sons_.size() != 0)
      removeSon(static_cast<size_t>(0));
  }
 
  virtual void swap(size_t branch1, size_t branch2);
 
  virtual size_t getSonPosition(const Node* son) const;
  
  // From PhyloNode
 
  /*
   * Add PhyloNode tree as Son of this Node
   */
  
  void addSubTree(const PhyloTree& tree, std::shared_ptr<PhyloNode> phyloNode);
  
  // These functions must not be declared as virtual!!
 
  std::vector<const Node*> getNeighbors() const;
 
  std::vector<Node*> getNeighbors();
 
  virtual size_t degree() const { return getNumberOfSons() + (hasFather() ? 1 : 0); }
 
  Node* operator[](int i) { return (i < 0) ? father_ : sons_[static_cast<size_t>(i)]; }
 
  const Node* operator[](int i) const { return (i < 0) ? father_ : sons_[static_cast<size_t>(i)]; }
 
  virtual void setNodeProperty(const std::string& name, const Clonable& property)
  {
    if (hasNodeProperty(name))
      delete nodeProperties_[name];
    nodeProperties_[name] = property.clone();
  }
 
  virtual Clonable* getNodeProperty(const std::string& name)
  {
    if (hasNodeProperty(name))
      return nodeProperties_[name];
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual const Clonable* getNodeProperty(const std::string& name) const
  {
    if (hasNodeProperty(name))
      return const_cast<const Clonable*>(nodeProperties_[name]);
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual Clonable* removeNodeProperty(const std::string& name)
  {
    if (hasNodeProperty(name))
    {
      Clonable* removed = nodeProperties_[name];
      nodeProperties_.erase(name);
      return removed;
    }
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual void deleteNodeProperty(const std::string& name)
  {
    if (hasNodeProperty(name))
    {
      delete nodeProperties_[name];
      nodeProperties_.erase(name);
    }
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual void removeNodeProperties()
  {
    nodeProperties_.clear();
  }
 
  virtual void deleteNodeProperties()
  {
    for (std::map<std::string, Clonable*>::iterator i = nodeProperties_.begin(); i != nodeProperties_.end(); i++)
    {
      delete i->second;
    }
    nodeProperties_.clear();
  }
 
  virtual bool hasNodeProperty(const std::string& name) const { return nodeProperties_.find(name) != nodeProperties_.end(); }
 
  virtual std::vector<std::string> getNodePropertyNames() const { return MapTools::getKeys(nodeProperties_); }
 
  virtual void setBranchProperty(const std::string& name, const Clonable& property)
  {
    if (hasBranchProperty(name))
      delete branchProperties_[name];
    branchProperties_[name] = property.clone();
  }
 
  virtual Clonable* getBranchProperty(const std::string& name)
  {
    if (hasBranchProperty(name))
      return branchProperties_[name];
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual const Clonable* getBranchProperty(const std::string& name) const
  {
    if (hasBranchProperty(name))
      return const_cast<const Clonable*>(branchProperties_[name]);
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual Clonable* removeBranchProperty(const std::string& name)
  {
    if (hasBranchProperty(name))
    {
      Clonable* removed = branchProperties_[name];
      branchProperties_.erase(name);
      return removed;
    }
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual void deleteBranchProperty(const std::string& name)
  {
    if (hasBranchProperty(name))
    {
      delete branchProperties_[name];
      branchProperties_.erase(name);
    }
    else
      throw PropertyNotFoundException("", name, this);
  }
 
  virtual void removeBranchProperties()
  {
    branchProperties_.clear();
  }
 
  virtual void deleteBranchProperties()
  {
    for (std::map<std::string, Clonable*>::iterator i = branchProperties_.begin(); i != branchProperties_.end(); i++)
    {
      delete i->second;
    }
    branchProperties_.clear();
  }
 
  virtual bool hasBranchProperty(const std::string& name) const { return branchProperties_.find(name) != branchProperties_.end(); }
 
  virtual std::vector<std::string> getBranchPropertyNames() const { return MapTools::getKeys(branchProperties_); }
 
  virtual bool hasBootstrapValue() const;
 
  virtual double getBootstrapValue() const;
  // Equality operator:
 
  virtual bool operator==(const Node& node) const { return id_ == node.id_; }
 
  // Tests:
 
  virtual bool isLeaf() const { return degree() <= 1; }
 
  virtual bool hasNoSon() const { return getNumberOfSons() == 0; }
};
} // end of namespace bpp.
#endif // BPP_PHYL_TREE_NODE_H