ExtendedNewick.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#include <Bpp/BppString.h>
#include <Bpp/Numeric/Number.h>
#include <Bpp/Text/NestedStringTokenizer.h>
#include <Bpp/Text/StringTokenizer.h>
#include <Bpp/Text/TextTools.h>
 
#include "../Tree/PhyloBranch.h"
#include "../Tree/PhyloNode.h"
#include "../Tree/PhyloDAG.h"
#include "ExtendedNewick.h"
 
using namespace bpp;
 
// From the STL:
#include <iostream>
#include <fstream>
 
using namespace std;
 
/******************************************************************************/
 
const string ExtendedNewick::getFormatName() const { return "ExtendedNewick"; }
 
/******************************************************************************/
 
const string ExtendedNewick::getFormatDescription() const
{
  return string("Extended Newick Format. ");
}
 
/**********************************************************/
/*  INPUT */
/**********************************************************/
 
 
unique_ptr<PhyloDAG> ExtendedNewick::readPhyloDAG(istream& in) const
{
  // Checking the existence of specified file
  if (!in)
  {
    throw IOException ("ExtendedNewick::readPhyloDAG: failed to read from stream");
  }
 
  // We concatenate all line in file till we reach the ending semi colon:
  string temp, description; // Initialization
  // Main loop : for all file lines
  while (getline(in, temp, '\n'))
  {
    string::size_type index = temp.find(";");
    if (index != string::npos)
    {
      description += temp.substr(0, index + 1);
      break;
    }
    else
      description += temp;
  }
 
  if (allowComments_)
    description = TextTools::removeSubstrings(description, '[', ']');
  if (TextTools::isEmpty(description))
    throw IOException("ExtendedNewick::read: no dag was found!");
  return parenthesisToPhyloDAG(description, verbose_);
}
 
 
/******************************************************************************/
 
void ExtendedNewick::readPhyloDAGs(istream& in, vector<unique_ptr<PhyloDAG>>& dags) const
{
  // Checking the existence of specified file
  if (!in)
  {
    throw IOException ("ExtendedNewick::readPhyloDAGs(vector): failed to read from stream");
  }
 
  // Main loop : for all file lines
  string temp, description; // Initialization
  string::size_type index;
  // We concatenate all line in file till we reach the ending semi colon:
  while (getline(in, temp, '\n'))
  {
    index = temp.find(";");
    if (index != string::npos)
    {
      description += temp.substr(0, index + 1);
      if (allowComments_)
        description = TextTools::removeSubstrings(description, '[', ']');
      dags.push_back(parenthesisToPhyloDAG(description, verbose_));
      description = temp.substr(index + 1);
    }
    else
      description += temp;
  }
  // In case the file is empty, the method will not add any neww dag to the vector.
}
 
/***************************************/
 
IODAG::Element ExtendedNewick::getElement(const string& elt) const
{
  IODAG::Element element;
  element.length    = ""; // default
  element.annotation = ""; // default
  element.isLeaf    = false; // default
 
  size_t colonIndex;
  bool hasColon = false;
  for (colonIndex = elt.size(); colonIndex > 0 && elt[colonIndex] != ')'; colonIndex--)
  {
    if (elt[colonIndex] == ':')
    {
      hasColon = true;
      break;
    }
  }
  try
  {
    string elt2;
    if (hasColon)
    {
      // this is an element with length:
      elt2 = elt.substr(0, colonIndex);
      element.length = TextTools::removeSurroundingWhiteSpaces(elt.substr(colonIndex + 1));
    }
    else
    {
      // this is an element without length;
      elt2 = elt;
    }
 
    string::size_type lastP = elt2.rfind(')');
    string::size_type firstP = elt2.find('(');
    if (firstP == string::npos)
    {
      // This is a leaf:
      element.content = elt2;
      element.isLeaf = true;
    }
    else
    {
      // This is a node:
      if (lastP < firstP)
        throw IOException("ExtendedNewick::getElement(). Invalid format: bad closing parenthesis in " + elt2);
      element.content = TextTools::removeSurroundingWhiteSpaces(elt2.substr(firstP + 1, lastP - firstP - 1));
      string annot = TextTools::removeSurroundingWhiteSpaces(elt2.substr(lastP + 1));
      if (!TextTools::isEmpty(annot))
      {
        element.annotation = annot;
      }
    }
    }
  }
  catch (exception& e)
  {
    throw IOException("Bad dag description: " + elt);
  }
  return element;
}
 
/************************************************************/
 
shared_ptr<PhyloNode>  ExtendedNewick::parenthesisToNode(PhyloDAG& dag, std::shared_ptr<PhyloNode>  father, const std::string& description, unsigned int& nodeCounter, unsigned int& branchCounter, std::map<std::string, std::shared_ptr<PhyloNode> >& mapEvent, bool withId, bool verbose) const
{
//  cout << "NODE: " << description << endl;
  IODAG::Element elt = getElement(description);
 
  // Is the node a connecting one?
 
  string annot = elt.annot;
  size_t poshash = elf.find("#");
 
  shared_ptr<PhyloNode> node;
  string label;
  
  // Check Event:
  if (poshash != string::pos)
  {
    string evId = annot.substr(poshash+1);
    label = annot.substr(0, poshash);
    
    if (mapEvent.find(evId)!=mapEvent.end())
      node=mapEvent[evId];
    else
    {
      node = std::make_shared<PhyloNode>();
      mapEvent[evId]=node;
      dag.createNode(node);
    }
  }    
  else
    label = annot;
    
  shared_ptr<PhyloBranch> branch(father ? new PhyloBranch() : 0);
  
  if (father)
  {
    dag.link(father, node, branch);
    
    if (!TextTools::isEmpty(elt.length))
      branch->setLength(TextTools::toDouble(elt.length));
  }
 
  
  if (annot.size()!=0)
  {
    if (withId)
    {
      auto id = static_cast<PhyloDAG::NodeIndex>(TextTools::toInt(elt.annotation));
      dag.setNodeIndex(node, id);
      // no direct connection betwenn nodeid & branchid
      // if (branch)
      //   dag.setEdgeIndex(branch, id); 
    }
  }
 
  NestedStringTokenizer nt(elt.content, "(", ")", ",");
  vector<string> elements;
  while (nt.hasMoreToken())
  {
    elements.push_back(nt.nextToken());
  }
 
  if (elt.isLeaf)
  {
    // This is a leaf:
    string name = TextTools::removeSurroundingWhiteSpaces(elements[0]);
    if (withId)
    {
      StringTokenizer st(name, "_", true, true);
      ostringstream realName;
      for (size_t i = 0; i < st.numberOfRemainingTokens() - 1; ++i)
      {
        if (i != 0)
        {
          realName << "_";
        }
        realName << st.getToken(i);
      }
      node->setName(realName.str());
      dag.setNodeIndex(node, static_cast<PhyloDAG::NodeIndex>(
            TextTools::toInt(st.getToken(st.numberOfRemainingTokens() - 1))));
      if (branch)
        dag.setEdgeIndex(branch, static_cast<PhyloDAG::NodeIndex>(
              TextTools::toInt(st.getToken(st.numberOfRemainingTokens() - 1))));
    }
    else
      node->setName(name);
  }
  else
  {
    // This is a node:
    for (size_t i = 0; i < elements.size(); i++)
    {
      //    cout << "NODE: SUBNODE: " << i << ", " << elements[i] << endl;
      parenthesisToNode(dag, node, elements[i], nodeCounter, branchCounter, mapEvent, withId, verbose);
    }
  }
 
  if (!withId)
  {
    if (dag.hasIndex(noode))
      dag.setNodeIndex(node, nodeCounter);
    if (branch)
      dag.setEdgeIndex(branch, branchCounter);
  }
 
  nodeCounter++;
  
  if (verbose)
    ApplicationTools::displayUnlimitedGauge(nodeCounter);
  return node;
}
 
/******************************************************************************/
 
unique_ptr<PhyloDAG> ExtendedNewick::parenthesisToPhyloDAG(const string& description, bool withId, bool verbose) const
{
  string::size_type semi = description.rfind(';');
  if (semi == string::npos)
    throw Exception("ExtendedNewick::parenthesisToPhyloDAG(). Bad format: no semi-colon found.");
  string content = description.substr(0, semi);
  unsigned int nodeCounter = 0;
  unsigned int branchCounter = 0;
  map<std::string, shared_ptr<PhyloNode> > mapEvent;
  
  auto dag = make_unique<PhyloDAG>();
  shared_ptr<PhyloNode> root = parenthesisToNode(*dag, 0, content, nodeCounter, branchCounter, mapEvent, withId, verbose);
  dag->rootAt(root);
  if (verbose)
  {
    (*ApplicationTools::message) << " nodes loaded.";
    ApplicationTools::message->endLine();
  }
 
  return dag;
}
 
/**********************************************************/
/*  OUTPUT */
/**********************************************************/
 
void ExtendedNewick::write_(const PhyloDAG& dag, ostream& out) const
{
  // Checking the existence of specified file, and possibility to open it in write mode
  if (!out)
  {
    throw IOException ("ExtendedNewick::writePhyloDAG: failed to write to stream");
  }
    out << dagToParenthesis(dag, writeId_);
}
 
 
/******************************************************************************/
 
void ExtendedNewick::write_(const vector<const PhyloDAG*>& dags, ostream& out) const
{
  // Checking the existence of specified file, and possibility to open it in write mode
  if (!out)
  {
    throw IOException ("ExtendedNewick::write: failed to write to stream");
  }
  for (unsigned int i = 0; i < dags.size(); i++)
    out << dagToParenthesis(*dags[i], writeId_);
 
}
 
/******************************************************************************/
 
string ExtendedNewick::nodeToParenthesis(const PhyloDAG& dag, const std::shared_ptr<PhyloNode> node, bool writeId) const
{
  ostringstream s;
  // shared_ptr<PhyloBranch> branch = dag.hasFather(node) ? dag.getEdgeToFather(node) : 0;
 
  // if (dag.getNumberOfSons(node) == 0)
  // {
  //   s << node->getName();
  // }
  // else
  // {
  //   s << "(";
 
  //   vector<shared_ptr<PhyloNode>> vSons = dag.getSons(node);
 
  //   for (vector<shared_ptr<PhyloNode>>::const_iterator it = vSons.begin(); it != vSons.end(); it++)
  //   {
  //     if (it != vSons.begin())
  //       s << ",";
 
  //     s << nodeToParenthesis(dag, *it);
  //   }
 
  //   s << ")";
  // }
 
  // if (writeId)
  // {
  //   if (dag.isLeaf(node))
  //     s << "_";
  //   s << dag.getNodeIndex(node);
  // }
 
  // if (branch && branch->hasLength())
  //   s << ":" << branch->getLength();
  return s.str();
}
 
/******************************************************************************/
 
string ExtendedNewick::dagToParenthesis(const PhyloDAG& dag, bool writeId) const
{
  ostringstream s;
  s << "(";
 
  shared_ptr<PhyloNode>  root = dag.getRoot();
 
  std::vector<shared_ptr<PhyloNode>> rSons = dag.getSons(root);
 
  if (dag.isRooted())
  {
    for (size_t i = 0; i < rSons.size(); ++i)
    {
      if (i != 0)
        s << ",";
      s << nodeToParenthesis(dag, rSons[i], writeId);
    }
  }
  else
  {
    s << root->getName();
 
    for (size_t i = 0; i < rSons.size(); ++i)
    {
      if (i != 0)
        s << ",";
      s << nodeToParenthesis(dag, rSons[i], writeId);
    }
  }
 
  s << ")";
 
  // const shared_ptr<PhyloBranch> branch = dag.hasFather(root) ? dag.getEdgeToFather(root) : 0;
 
  // if (branch && branch->hasLength())
  //   s << ":" << branch->getLength();
  s << ";" << endl;
 
  return s.str();
}
 
/******************************************************************************/
 
string ExtendedNewick::dagToParenthesis(const PhyloDAG& dag) const
{
  ostringstream s;
  s << "(";
 
  shared_ptr<PhyloNode>  root = dag.getRoot();
 
  std::vector<shared_ptr<PhyloNode>> rSons = dag.getSons(root);
 
  if (dag.isRooted())
  {
    for (size_t i = 0; i < rSons.size(); ++i)
    {
      if (i != 0)
        s << ",";
      s << nodeToParenthesis(dag, rSons[i]);
    }
  }
  else
  {
    s << root->getName();
 
    for (size_t i = 0; i < rSons.size(); ++i)
    {
      if (i != 0)
        s << ",";
      s << nodeToParenthesis(dag, rSons[i]);
    }
  }
 
  s << ")";
 
  // shared_ptr<PhyloBranch> branch = dag.hasFather(root) ? dag.getEdgeToFather(root) : 0;
 
  s << ";" << endl;
  return s.str();
}