PhyloNode.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_TREE_PHYLONODE_H
#define BPP_PHYL_TREE_PHYLONODE_H
 
#include <Bpp/Clonable.h>
#include <Bpp/Utils/MapTools.h>
#include <memory>
 
#include "PhyloTreeExceptions.h"
 
namespace bpp
{
/***********
 * For each PhyloNode of the tree, a description of the event at the node.
 *
 * It will determine the choice of the computing operator on this node.
 *
 */
 
class NodeEvent : public Clonable
{
  enum class NodeType
  {
    Speciation = 0,
    Mixture = 1,
    Hybridization = 2
  };
 
  NodeType nodeType_;
 
public:
  NodeEvent(NodeType type) { nodeType_ = type;}
 
  // NodeEvent(const NodeEvent& event) :
  //   nodeType_(event.nodeType_) {}
 
  NodeEvent* clone() const { return new NodeEvent(*this);}
 
  bool isSpeciation() const { return nodeType_ == NodeType::Speciation;}
 
  bool isMixture() const {return nodeType_ == NodeType::Mixture;}
 
  bool isHybridization() const { return nodeType_ == NodeType::Hybridization;}
 
public:
  static const NodeEvent speciationEvent;
  static const NodeEvent mixtureEvent;
  static const NodeEvent hybridizationEvent;
 
  std::string toString() const
  {
    if (isSpeciation())
      return "speciation";
    else if (isMixture())
      return "mixture";
    else
      return "hybridization";
  }
};
 
 
class PhyloNode
{
private:
  // a name, if specified
  std::string name_;
 
  // Node properties
  mutable std::map<std::string, Clonable*> properties_;
 
public:
  PhyloNode() :
    name_(""),
    properties_()
  {}
 
  PhyloNode(const std::string& name) :
    name_(name),
    properties_()
  {}
 
  PhyloNode(const PhyloNode& node);
 
  PhyloNode& operator=(const PhyloNode& node);
 
  PhyloNode* clone() const { return new PhyloNode(*this); }
 
  virtual ~PhyloNode()
  {
    deleteProperties();
  }
 
public:
  std::string getName() const
  {
    if (!hasName()) throw PhyloNodePException("Node::getName: no name associated to this node.", this);
    return name_;
  }
 
  void setName(const std::string& name)
  {
    name_ = name;
  }
 
  void deleteName()
  {
    name_ = "";
  }
 
  bool hasName() const { return name_ != ""; }
 
  void setProperty(const std::string& name, const Clonable& property)
  {
    if (hasProperty(name))
      delete properties_[name];
    properties_[name] = property.clone();
  }
 
  Clonable* getProperty(const std::string& name)
  {
    if (hasProperty(name))
      return properties_[name];
    else
      throw PhyloNodePropertyNotFoundException("", name, this);
  }
 
  const Clonable* getProperty(const std::string& name) const
  {
    if (hasProperty(name))
      return const_cast<const Clonable*>(properties_[name]);
    else
      throw PhyloNodePropertyNotFoundException("", name, this);
  }
 
  Clonable* removeProperty(const std::string& name)
  {
    if (hasProperty(name))
    {
      Clonable* removed = properties_[name];
      properties_.erase(name);
      return removed;
    }
    else
      throw PhyloNodePropertyNotFoundException("", name, this);
  }
 
  void deleteProperty(const std::string& name)
  {
    if (hasProperty(name))
    {
      delete properties_[name];
      properties_.erase(name);
    }
    else
      throw PhyloNodePropertyNotFoundException("", name, this);
  }
 
  void removeProperties()
  {
    properties_.clear();
  }
 
  void deleteProperties()
  {
    for (std::map<std::string, Clonable*>::iterator i = properties_.begin(); i != properties_.end(); i++)
    {
      delete i->second;
    }
    properties_.clear();
  }
 
  bool hasProperty(const std::string& name) const { return properties_.find(name) != properties_.end(); }
 
  std::vector<std::string> getPropertyNames() const { return MapTools::getKeys(properties_); }
}; // end of class node
} // end of namespace bpp.
 
#else
namespace bpp { class PhyloNode; }
#endif // BPP_PHYL_TREE_PHYLONODE_H