TreeExceptions.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_TREE_TREEEXCEPTIONS_H
#define BPP_PHYL_TREE_TREEEXCEPTIONS_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Text/TextTools.h>
 
 
// From the STL:
#include <string>
 
namespace bpp
{
class Node;
class Tree;
 
class NodeException :
  public Exception
{
protected:
  int nodeId_;
 
public:
  NodeException(const std::string& text, int nodeId) :
    Exception("NodeException: " + text + "(id:" + TextTools::toString(nodeId) + ")"),
    nodeId_(nodeId) {}
 
  virtual ~NodeException() {}
 
public:
  virtual int getNodeId() const { return nodeId_; }
};
 
 
class NodePException :
  public NodeException
{
private:
  const Node* node_;
 
public:
  NodePException(const std::string& text, const Node* node = 0);
 
  NodePException(const std::string& text, int nodeId) :
    NodeException(text, nodeId), node_(0) {}
 
  NodePException(const NodePException& nex) :
    NodeException(nex),
    node_(nex.node_)
  {}
 
  NodePException& operator=(const NodePException& nex)
  {
    NodeException::operator=(nex);
    node_ = nex.node_;
    return *this;
  }
 
  virtual ~NodePException() {}
 
public:
  virtual const Node* getNode() const { return node_; }
  virtual int getNodeId() const { return nodeId_; }
};
 
class PropertyNotFoundException :
  public NodePException
{
private:
  std::string propertyName_;
 
public:
  PropertyNotFoundException(const std::string& text, const std::string& propertyName, const Node* node = 0) :
    NodePException("Property not found: " + propertyName + ". " + text, node),
    propertyName_(propertyName) {}
 
  PropertyNotFoundException(const std::string& text, const std::string& propertyName, int nodeId) :
    NodePException("Property not found: " + propertyName + ". " + text, nodeId),
    propertyName_(propertyName) {}
 
  virtual ~PropertyNotFoundException() {}
 
public:
  virtual const std::string& getPropertyName() const { return propertyName_; }
};
 
class NodeNotFoundException :
  public Exception
{
private:
  std::string id_;
 
public:
  NodeNotFoundException(const std::string& text, const std::string& id);
 
  NodeNotFoundException(const std::string& text, int id);
 
  virtual ~NodeNotFoundException() {}
 
public:
  virtual std::string getId() const { return id_; }
};
 
class TreeException :
  public Exception
{
private:
  const Tree* tree_;
 
public:
  TreeException(const std::string& text, const Tree* tree = 0);
 
  TreeException(const TreeException& tex) :
    Exception(tex),
    tree_(tex.tree_)
  {}
 
  TreeException& operator=(const TreeException& tex)
  {
    Exception::operator=(tex);
    tree_ = tex.tree_;
    return *this;
  }
 
  virtual ~TreeException() {}
 
public:
  virtual const Tree* getTree() const { return tree_; }
};
 
class UnrootedTreeException :
  public TreeException
{
public:
  UnrootedTreeException(const std::string& text, const Tree* tree = 0);
 
  virtual ~UnrootedTreeException() {}
};
} // end of namespace bpp.
#endif // BPP_PHYL_TREE_TREEEXCEPTIONS_H