Nhx.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_IO_NHX_H
#define BPP_PHYL_IO_NHX_H
 
 
#include "../Tree/PhyloTree.h"
#include "../Tree/TreeTemplate.h"
#include "IoTree.h"
 
// From the STL:
#include <set>
 
namespace bpp
{
class Nhx :
  public AbstractITree,
  public AbstractOTree,
  public AbstractIMultiTree,
  public AbstractOMultiTree,
  public AbstractIPhyloTree,
  public AbstractOPhyloTree,
  public AbstractIMultiPhyloTree,
  public AbstractOMultiPhyloTree
{
public:
  struct Property
  {
public:
    std::string name;
    std::string tag;
    bool onBranch;
    short type;
 
public:
    Property(const std::string& pptName, const std::string& pptTag, bool pptOnBranch = false, short pptType = 0) :
      name(pptName),
      tag(pptTag),
      onBranch(pptOnBranch),
      type(pptType) {}
 
    bool operator<(const Property& ppt) const
    {
      return name < ppt.name;
    }
  };
 
private:
  std::set<Property> supportedProperties_;
  bool useTagsAsPropertyNames_;
  mutable bool hasIds_;
 
public:
  Nhx(bool useTagsAsPptNames = true);
  virtual ~Nhx() {}
 
public:
  const std::string getFormatName() const override;
  const std::string getFormatDescription() const override;
  /* @} */
 
  using AbstractITree::readTreeTemplate;
 
  std::unique_ptr<TreeTemplate<Node>> readTreeTemplate(std::istream& in) const override;
 
  using AbstractIPhyloTree::readPhyloTree;
 
  std::unique_ptr<PhyloTree> readPhyloTree(std::istream& in) const override;
 
  using AbstractOTree::writeTree;
 
  void writeTree(const Tree& tree, std::ostream& out) const override
  {
    write_(tree, out);
  }
 
  using AbstractOPhyloTree::writePhyloTree;
 
  void writePhyloTree(const PhyloTree& tree, std::ostream& out) const override
  {
    write_(tree, out);
  }
  using AbstractIMultiTree::readTrees;
 
  void readTrees(std::istream& in, std::vector<std::unique_ptr<Tree>>& trees) const override;
 
  using AbstractIMultiPhyloTree::readPhyloTrees;
 
  void readPhyloTrees(std::istream& in, std::vector<std::unique_ptr<PhyloTree>>& trees) const override;
 
  using AbstractOMultiTree::writeTrees;
 
  void writeTrees(const std::vector<const Tree*>& trees, std::ostream& out) const override
  {
    write_(trees, out);
  }
 
  using AbstractOMultiPhyloTree::writePhyloTrees;
 
  void writePhyloTrees(const std::vector<const PhyloTree*>& trees, std::ostream& out) const override
  {
    write_(trees, out);
  }
  std::unique_ptr<TreeTemplate<Node>> parenthesisToTree(const std::string& description) const;
 
  std::unique_ptr<PhyloTree> parenthesisToPhyloTree(const std::string& description) const;
 
  std::string treeToParenthesis(const TreeTemplate<Node>& tree) const;
 
  std::string treeToParenthesis(const PhyloTree& tree) const;
 
  void registerProperty(const Property& property)
  {
    supportedProperties_.insert(property);
  }
 
  void changeTagsToNames(Node& node) const;
  void changeTagsToNames(PhyloTree& tree, std::shared_ptr<PhyloNode> node) const;
 
  void changeNamesToTags(Node& node) const;
  void changeNamesToTags(PhyloTree& tree, std::shared_ptr<PhyloNode> node) const;
 
  void useTagsAsPropertyNames(bool yn) { useTagsAsPropertyNames_ = yn; }
  bool useTagsAsPropertyNames() const { return useTagsAsPropertyNames_; }
 
protected:
  void write_(const Tree& tree, std::ostream& out) const;
 
  void write_(const PhyloTree& tree, std::ostream& out) const;
 
  template<class N>
  void write_(const TreeTemplate<N>& tree, std::ostream& out) const;
 
  void write_(const std::vector<const Tree*>& trees, std::ostream& out) const;
 
  void write_(const std::vector<const PhyloTree*>& trees, std::ostream& out) const;
 
  template<class N>
  void write_(const std::vector<TreeTemplate<N>*>& trees, std::ostream& out) const;
 
  IOTree::Element getElement(const std::string& elt) const override;
 
private:
  Node* parenthesisToNode(const std::string& description) const;
 
  std::shared_ptr<PhyloNode> parenthesisToNode(PhyloTree& tree, std::shared_ptr<PhyloNode> father, const std::string& description) const;
 
public:
  std::string propertiesToParenthesis(const Node& node) const;
 
  std::string propertiesToParenthesis(const PhyloTree& tree, const std::shared_ptr<PhyloNode> node) const;
 
protected:
  std::string nodeToParenthesis(const Node& node) const;
 
  std::string nodeToParenthesis(const PhyloTree& tree, const std::shared_ptr<PhyloNode> node) const;
 
  bool setNodeProperties(Node& node, const std::string properties) const;
 
  bool setNodeProperties(PhyloTree& tree, std::shared_ptr<PhyloNode> node, const std::string properties) const;
 
protected:
  static std::string propertyToString_(const Clonable* pptObject, short type);
  static Clonable* stringToProperty_(const std::string& pptDesc, short type);
 
  void checkNodesId_(PhyloTree& tree) const;
};
} // end of namespace bpp.
#endif // BPP_PHYL_IO_NHX_H