PhyloTreeExceptions.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_TREE_PHYLOTREEEXCEPTIONS_H
#define BPP_PHYL_TREE_PHYLOTREEEXCEPTIONS_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Text/TextTools.h>
 
 
// From the STL:
#include <string>
#include <memory>
 
namespace bpp
{
class PhyloNode;
class PhyloBranch;
class PhyloTree;
 
class PhyloNodeException :
  public Exception
{
protected:
  uint nodeId_;
 
public:
  PhyloNodeException(const std::string& text, uint nodeId) :
    Exception("PhyloNodeException: " + text + "(id:" + TextTools::toString(nodeId) + ")"),
    nodeId_(nodeId) {}
 
  virtual ~PhyloNodeException() {}
 
public:
  virtual uint getNodeId() const { return nodeId_; }
};
 
 
class PhyloNodePException :
  public PhyloNodeException
{
private:
  const PhyloNode* node_;
 
public:
  PhyloNodePException(const std::string& text, const PhyloTree& tree, const std::shared_ptr<PhyloNode> node);
 
  PhyloNodePException(const std::string& text, const PhyloNode* node);
 
  PhyloNodePException(const std::string& text, uint nodeId) :
    PhyloNodeException(text, nodeId), node_(0) {}
 
  PhyloNodePException(const PhyloNodePException& nex) :
    PhyloNodeException(nex),
    node_(nex.node_)
  {}
 
  PhyloNodePException& operator=(const PhyloNodePException& nex)
  {
    PhyloNodeException::operator=(nex);
    node_ = nex.node_;
    return *this;
  }
 
  virtual ~PhyloNodePException() {}
 
public:
  virtual const PhyloNode* getNode() const { return node_; }
  virtual uint getNodeId() const { return nodeId_; }
};
 
class PhyloNodePropertyNotFoundException :
  public PhyloNodePException
{
private:
  std::string propertyName_;
 
public:
  PhyloNodePropertyNotFoundException(const std::string& text, const std::string& propertyName, const PhyloTree& tree, const std::shared_ptr<PhyloNode> node) :
    PhyloNodePException("Property not found: " + propertyName + ". " + text, tree, node),
    propertyName_(propertyName) {}
 
  PhyloNodePropertyNotFoundException(const std::string& text, const std::string& propertyName, const PhyloNode* node) :
    PhyloNodePException("Property not found: " + propertyName + ". " + text, node),
    propertyName_(propertyName) {}
 
  PhyloNodePropertyNotFoundException(const std::string& text, const std::string& propertyName, uint nodeId) :
    PhyloNodePException("Property not found: " + propertyName + ". " + text, nodeId),
    propertyName_(propertyName) {}
 
  virtual ~PhyloNodePropertyNotFoundException() {}
 
public:
  virtual const std::string& getPropertyName() const { return propertyName_; }
};
 
class PhyloNodeNotFoundException :
  public Exception
{
private:
  std::string id_;
 
public:
  PhyloNodeNotFoundException(const std::string& text, const std::string& id);
 
  PhyloNodeNotFoundException(const std::string& text, uint id);
 
  virtual ~PhyloNodeNotFoundException() {}
 
public:
  virtual std::string getId() const { return id_; }
};
 
class PhyloBranchException :
  public Exception
{
protected:
  uint branchId_;
 
public:
  PhyloBranchException(const std::string& text, uint branchId) :
    Exception("PhyloBranchException: " + text + "(id:" + TextTools::toString(branchId) + ")"),
    branchId_(branchId) {}
 
  virtual ~PhyloBranchException() {}
 
public:
  virtual uint getBranchId() const { return branchId_; }
};
 
 
class PhyloBranchPException :
  public PhyloBranchException
{
private:
  const PhyloBranch* branch_;
 
public:
  PhyloBranchPException(const std::string& text, const PhyloTree& tree, const std::shared_ptr<PhyloBranch> branch);
 
  PhyloBranchPException(const std::string& text, const PhyloBranch* branch);
 
  PhyloBranchPException(const std::string& text, uint branchId) :
    PhyloBranchException(text, branchId), branch_(0) {}
 
  PhyloBranchPException(const PhyloBranchPException& nex) :
    PhyloBranchException(nex),
    branch_(nex.branch_)
  {}
 
  PhyloBranchPException& operator=(const PhyloBranchPException& nex)
  {
    PhyloBranchException::operator=(nex);
    branch_ = nex.branch_;
    return *this;
  }
 
  virtual ~PhyloBranchPException() {}
 
public:
  virtual const PhyloBranch* getBranch() const { return branch_; }
  virtual uint getBranchId() const { return branchId_; }
};
 
class PhyloBranchPropertyNotFoundException :
  public PhyloBranchPException
{
private:
  std::string propertyName_;
 
public:
  PhyloBranchPropertyNotFoundException(const std::string& text, const std::string& propertyName, const PhyloTree& tree, const std::shared_ptr<PhyloBranch> branch) :
    PhyloBranchPException("Property not found: " + propertyName + ". " + text, tree, branch),
    propertyName_(propertyName) {}
 
  PhyloBranchPropertyNotFoundException(const std::string& text, const std::string& propertyName, const PhyloBranch* branch) :
    PhyloBranchPException("Property not found: " + propertyName + ". " + text, branch),
    propertyName_(propertyName) {}
 
  PhyloBranchPropertyNotFoundException(const std::string& text, const std::string& propertyName, uint branchId) :
    PhyloBranchPException("Property not found: " + propertyName + ". " + text, branchId),
    propertyName_(propertyName) {}
 
  virtual ~PhyloBranchPropertyNotFoundException() {}
 
public:
  virtual const std::string& getPropertyName() const { return propertyName_; }
};
 
class PhyloBranchNotFoundException :
  public Exception
{
private:
  std::string id_;
 
public:
  PhyloBranchNotFoundException(const std::string& text, const std::string& id);
 
  PhyloBranchNotFoundException(const std::string& text, uint id);
 
  virtual ~PhyloBranchNotFoundException() {}
 
public:
  virtual std::string getId() const { return id_; }
};
 
class PhyloTreeException :
  public Exception
{
private:
  const PhyloTree* tree_;
 
public:
  PhyloTreeException(const std::string& text, const PhyloTree* tree = 0);
 
  PhyloTreeException(const PhyloTreeException& tex) :
    Exception(tex),
    tree_(tex.tree_)
  {}
 
  PhyloTreeException& operator=(const PhyloTreeException& tex)
  {
    Exception::operator=(tex);
    tree_ = tex.tree_;
    return *this;
  }
 
  virtual ~PhyloTreeException() {}
 
public:
  virtual const PhyloTree* getTree() const { return tree_; }
};
 
class UnrootedPhyloTreeException :
  public PhyloTreeException
{
public:
  UnrootedPhyloTreeException(const std::string& text, const PhyloTree* tree = 0);
 
  virtual ~UnrootedPhyloTreeException() {}
};
} // end of namespace bpp.
#endif // BPP_PHYL_TREE_PHYLOTREEEXCEPTIONS_H