IoTree.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_IO_IOTREE_H
#define BPP_PHYL_IO_IOTREE_H
 
 
#include "../Tree/PhyloTree.h"
#include "../Tree/Tree.h"
 
// From the STL:
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <memory>
 
#include <Bpp/Exceptions.h>
#include <Bpp/Io/IoFormat.h>
 
namespace bpp
{
class IOTree :
  public virtual IOFormat
{
protected:
  struct Element
  {
public:
    std::string content;
    std::string length;
    std::string annotation;
    bool isLeaf;
 
public:
    Element() : content(),
      length(),
      annotation(),
      isLeaf(false) {}
  };
 
public:
  IOTree() {}
  virtual ~IOTree() {}
 
public:
  virtual const std::string getDataType() const { return "Tree"; }
};
 
class ITree :
  public virtual IOTree
{
  /*
   * @brief Basic element for branch description.
   *
   */
 
public:
  ITree() {}
  virtual ~ITree() {}
 
public:
  virtual std::unique_ptr<Tree> readTree(const std::string& path) const = 0;
 
  virtual std::unique_ptr<Tree> readTree(std::istream& in) const = 0;
};
 
class IPhyloTree :
  public virtual IOTree
{
public:
  IPhyloTree() {}
  virtual ~IPhyloTree() {}
 
public:
  virtual std::unique_ptr<PhyloTree> readPhyloTree(const std::string& path) const = 0;
 
  virtual std::unique_ptr<PhyloTree> readPhyloTree(std::istream& in) const = 0;
};
 
 
class OTree :
  public virtual IOTree
{
public:
  OTree() {}
  virtual ~OTree() {}
 
public:
  virtual void writeTree(const Tree& tree, const std::string& path, bool overwrite) const = 0;
 
  virtual void writeTree(const Tree& tree, std::ostream& out) const = 0;
};
 
class OPhyloTree :
  public virtual IOTree
{
public:
  OPhyloTree() {}
  virtual ~OPhyloTree() {}
 
public:
  virtual void writePhyloTree(const PhyloTree& tree, const std::string& path, bool overwrite) const = 0;
 
  virtual void writePhyloTree(const PhyloTree& tree, std::ostream& out) const =  0;
};
 
class AbstractITree :
  public virtual ITree
{
public:
  AbstractITree() {}
  virtual ~AbstractITree() {}
 
public:
  std::unique_ptr<Tree> readTree(std::istream& in) const override
  {
    auto tree = readTreeTemplate(in);
    return std::unique_ptr<Tree>(tree.release());
  }
 
  std::unique_ptr<Tree> readTree(const std::string& path) const override
  {
    std::ifstream input(path.c_str(), std::ios::in);
    auto tree = readTree(input);
    input.close();
    return tree;
  }
 
  virtual std::unique_ptr<TreeTemplate<Node>> readTreeTemplate(std::istream& in) const = 0;
 
  virtual std::unique_ptr<TreeTemplate<Node>> readTreeTemplate(const std::string& path) const
  {
    std::ifstream input(path.c_str(), std::ios::in);
    auto tree = readTreeTemplate(input);
    input.close();
    return tree;
  }
 
  virtual Element getElement(const std::string& elt) const
  {
    return Element();
  }
};
 
class AbstractIPhyloTree :
  public virtual IPhyloTree
{
public:
  AbstractIPhyloTree() {}
  virtual ~AbstractIPhyloTree() {}
 
public:
  std::unique_ptr<PhyloTree> readPhyloTree(std::istream& in) const override = 0;
 
  std::unique_ptr<PhyloTree> readPhyloTree(const std::string& path) const override
  {
    std::ifstream input(path.c_str(), std::ios::in);
    if (!input)
      throw IOException ("AbstractIPhyloTree::readPhyloTree(path): failed to read from path " + path);
    auto tree = readPhyloTree(input);
    input.close();
    return tree;
  }
 
  Element getElement(const std::string& elt) const
  {
    return Element();
  }
};
 
class AbstractOTree :
  public virtual OTree
{
public:
  AbstractOTree() {}
  virtual ~AbstractOTree() {}
 
public:
  virtual void writeTree(const Tree& tree, std::ostream& out) const = 0;
  virtual void writeTree(const Tree& tree, const std::string& path, bool overwrite) const
  {
    try
    {
      // Open file in specified mode
 
      std::ofstream output(path.c_str(), overwrite ? (std::ios::out) : (std::ios::out | std::ios::app));
      if (!output)
        throw Exception("Problem opening file " + path + "in write Tree.");
      writeTree(tree, output);
      output.close();
    }
    catch (IOException& e)
    {
      std::stringstream ss;
      ss << e.what() << "\nProblem writing tree to file " << path << "\n Is the file path correct and do \
you have the proper authorizations? ";
      throw (IOException ( ss.str() ) );
    }
  }
};
 
class AbstractOPhyloTree :
  public virtual OPhyloTree
{
public:
  AbstractOPhyloTree() {}
  virtual ~AbstractOPhyloTree() {}
 
public:
  virtual void writePhyloTree(const PhyloTree& tree, std::ostream& out) const = 0;
  virtual void writePhyloTree(const PhyloTree& tree, const std::string& path, bool overwrite) const
  {
    try
    {
      // Open file in specified mode
 
      std::ofstream output(path.c_str(), overwrite ? (std::ios::out) : (std::ios::out | std::ios::app));
      if (!output)
        throw Exception("Problem opening file " + path + "in writePhyloTree.");
      writePhyloTree(tree, output);
      output.close();
    }
    catch (IOException& e)
    {
      std::stringstream ss;
      ss << e.what() << "\nProblem writing tree to file " << path << "\n Is the file path correct and do \
you have the proper authorizations? ";
      throw (IOException ( ss.str() ) );
    }
  }
};
 
 
class IMultiTree :
  public virtual IOTree
{
public:
  IMultiTree() {}
  virtual ~IMultiTree() {}
 
public:
  virtual void readTrees(const std::string& path, std::vector<std::unique_ptr<Tree>>& trees) const = 0;
 
  virtual void readTrees(std::istream& in, std::vector<std::unique_ptr<Tree>>& trees) const = 0;
};
 
class IMultiPhyloTree :
  public virtual IOTree
{
public:
  IMultiPhyloTree() {}
  virtual ~IMultiPhyloTree() {}
 
public:
  virtual void readPhyloTrees(const std::string& path, std::vector<std::unique_ptr<PhyloTree>>& trees) const = 0;
 
  virtual void readPhyloTrees(std::istream& in, std::vector<std::unique_ptr<PhyloTree>>& trees) const = 0;
};
 
class OMultiTree :
  public virtual IOTree
{
public:
  OMultiTree() {}
  virtual ~OMultiTree() {}
 
public:
  virtual void writeTrees(
      const std::vector<const Tree*>& trees,
      const std::string& path,
      bool overwrite) const = 0;
 
  virtual void writeTrees(
      const std::vector<const Tree*>& trees,
      std::ostream& out) const = 0;
};
 
class OMultiPhyloTree :
  public virtual IOTree
{
public:
  OMultiPhyloTree() {}
  virtual ~OMultiPhyloTree() {}
 
public:
  virtual void writePhyloTrees(
      const std::vector<const PhyloTree*>& trees,
      const std::string& path,
      bool overwrite) const = 0;
 
  virtual void writePhyloTrees(
      const std::vector<const PhyloTree*>& trees,
      std::ostream& out) const = 0;
};
 
class AbstractIMultiTree :
  public virtual IMultiTree
{
public:
  AbstractIMultiTree() {}
  virtual ~AbstractIMultiTree() {}
 
public:
  virtual void readTrees(std::istream& in, std::vector<std::unique_ptr<Tree>>& trees) const override = 0;
 
  virtual void readTrees(const std::string& path, std::vector<std::unique_ptr<Tree>>& trees) const override
  {
    std::ifstream input(path.c_str(), std::ios::in);
    readTrees(input, trees);
    input.close();
  }
};
 
class AbstractIMultiPhyloTree :
  public virtual IMultiPhyloTree
{
public:
  AbstractIMultiPhyloTree() {}
  virtual ~AbstractIMultiPhyloTree() {}
 
public:
  virtual void readPhyloTrees(std::istream& in, std::vector<std::unique_ptr<PhyloTree>>& trees) const override = 0;
 
  virtual void readPhyloTrees(const std::string& path, std::vector<std::unique_ptr<PhyloTree>>& trees) const override
  {
    std::ifstream input(path.c_str(), std::ios::in);
    readPhyloTrees(input, trees);
    input.close();
  }
};
 
class AbstractOMultiTree :
  public virtual OMultiTree
{
public:
  AbstractOMultiTree() {}
  virtual ~AbstractOMultiTree() {}
 
public:
  virtual void writeTrees(const std::vector<const Tree*>& trees, std::ostream& out) const = 0;
  virtual void writeTrees(const std::vector<const Tree*>& trees, const std::string& path, bool overwrite) const
 
  {
    // Open file in specified mode
    std::ofstream output(path.c_str(), overwrite ? (std::ios::out) : (std::ios::out | std::ios::app));
    writeTrees(trees, output);
    output.close();
  }
};
 
class AbstractOMultiPhyloTree :
  public virtual OMultiPhyloTree
{
public:
  AbstractOMultiPhyloTree() {}
  virtual ~AbstractOMultiPhyloTree() {}
 
public:
  virtual void writePhyloTrees(const std::vector<const PhyloTree*>& trees, std::ostream& out) const = 0;
 
  virtual void writePhyloTrees(const std::vector<const PhyloTree*>& trees, const std::string& path, bool overwrite) const
 
  {
    // Open file in specified mode
    std::ofstream output(path.c_str(), overwrite ? (std::ios::out) : (std::ios::out | std::ios::app));
    writePhyloTrees(trees, output);
    output.close();
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_IO_IOTREE_H