Newick.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_IO_NEWICK_H
#define BPP_PHYL_IO_NEWICK_H
 
 
#include "../Tree/PhyloTree.h"
#include "../Tree/TreeTemplate.h"
#include "IoTree.h"
 
namespace bpp
{
class Newick :
  public AbstractITree,
  public AbstractOTree,
  public AbstractIMultiTree,
  public AbstractOMultiTree,
  public AbstractIPhyloTree,
  public AbstractOPhyloTree,
  public AbstractIMultiPhyloTree,
  public AbstractOMultiPhyloTree
{
protected:
  bool allowComments_;
  bool writeId_;
  bool useBootstrap_;
  std::string bootstrapPropertyName_;
  bool verbose_;
 
public:
  Newick(bool allowComments = false, bool writeId = false, bool verbose = false) :
    allowComments_(allowComments),
    writeId_(writeId),
    useBootstrap_(true),
    bootstrapPropertyName_("bootstrap"),
    verbose_(verbose) {}
 
  virtual ~Newick() {}
 
public:
  void enableExtendedBootstrapProperty(const std::string& propertyName)
  {
    useBootstrap_ = false;
    bootstrapPropertyName_ = propertyName;
  }
 
  void disableExtendedBootstrapProperty()
  {
    useBootstrap_ = true;
    bootstrapPropertyName_ = "bootstrap";
  }
 
  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;
 
private:
  std::shared_ptr<PhyloNode> parenthesisToNode(
      PhyloTree& tree,
      std::shared_ptr<PhyloNode> father,
      const std::string& description,
      unsigned int& nodeCounter,
      bool bootstrap,
      const std::string& propertyName,
      bool withId,
      bool verbose) const;
 
public:
  std::unique_ptr<PhyloTree> parenthesisToPhyloTree(
      const std::string& description,
      bool bootstrap = false,
      const std::string& propertyName = "",
      bool withId = false,
      bool verbose = false) const;
 
public:
  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);
  }
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;
 
  std::string nodeToParenthesis(const PhyloTree& tree, std::shared_ptr<PhyloNode> node, bool writeId = false) const;
 
/* @brief Get the parenthesis description of a subtree.
 *
 * @param tree The tree
 * @param node The node defining the subtree.
 * @param bootstrap Tell is bootstrap values must be written.
 * If so, the content of the property with name "bootstrap" will be written as bootstrap value.
 * The property should be a Number<double> object.
 * Otherwise, the content of the property with name 'propertyName' will be written.
 * In this later case, the property should be a String object.
 * @param propertyName The name of the property to use. Only used if bootstrap = false.
 * @return A string in the parenthesis format.
 */
 
  std::string nodeToParenthesis(const PhyloTree& tree, std::shared_ptr<PhyloNode> node, bool bootstrap, const std::string& propertyName) const;
 
  std::string treeToParenthesis(const PhyloTree& tree, bool writeId = false) const;
 
  std::string treeToParenthesis(const PhyloTree& tree, bool bootstrap, const std::string& propertyName) const;
};
} // end of namespace bpp.
#endif // BPP_PHYL_IO_NEWICK_H