parse.cc File Reference

#include "genealogy.h"
#include "generics.h"
#include "internal.h"
#include <regex>
#include <unordered_map>

Include dependency graph for parse.cc:

Go to the source code of this file.

Functions
static name_t	scan_name (const string_t &s)
static color_t	scan_color (const std::string &s)
	simple function for scanning the color
static slate_t	scan_branch_length (string_t::const_iterator b, string_t::const_iterator e)
	Scan the branch length.
SEXP	parse_newick (SEXP X, SEXP T0, SEXP Tf)

Function Documentation

parse_newick()

SEXP parse_newick	(	SEXP	X,
		SEXP	T0,
		SEXP	Tf )

A parser for Newick code. Returns a genealogy in the phylopomp format.

Definition at line 259 of file parse.cc.

                                               {
    PROTECT(X = AS_CHARACTER(X));
    PROTECT(T0 = AS_NUMERIC(T0));
    PROTECT(Tf = AS_NUMERIC(Tf));
    double t0 = *REAL(T0);
    double tf = *REAL(Tf);
    // parse the Newick representation into a genealogy:
    string_t x = CHAR(STRING_ELT(X,0));
    genealogy_t G(t0);
    G.parse(x);
    if (!ISNA(tf)) {
      G.curtail(tf,t0);
    }
    G.trace_lineages();
    UNPROTECT(3);
    return serial(G);
  }

Here is the call graph for this function:

scan_branch_length()

static slate_t scan_branch_length ( string_t::const_iterator b, string_t::const_iterator e )

static

Scan the branch length.

Definition at line 90 of file parse.cc.

{
  double bl = 0.0;
  if (b != e) {
    std::smatch m;
    if (std::regex_match(b,e,m,std::regex("^(?:\\[.*?\\])?([-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)(?:\\[.*?\\])?$"))) {
      try {
        bl = stod(m[1].str());
      }
      catch (const std::invalid_argument& e) {
        err("in '%s': invalid Newick format: branch length should be a non-negative decimal number.",__func__);
      }
      catch (const std::out_of_range& e) {
        err("in '%s': invalid Newick format: branch length out of range.",__func__);
      }
      catch (const std::exception& e) {
        err("in '%s': parsing branch-length: %s.",__func__,e.what());
      }
      catch (...) {
        err("in '%s': other branch-length parsing error.",__func__);
      }
      if (bl < 0.0) err("in '%s': negative branch length detected.",__func__);
    } else {
      warn("in '%s': in branch-length spec '%s': no branch-length detected: assuming zero branch length.",__func__,string_t(b,e).c_str());
    }
  }
  return bl;
}

Here is the caller graph for this function:

scan_color()

static color_t scan_color ( const std::string & s )

static

simple function for scanning the color

Definition at line 67 of file parse.cc.

{
  std::string copy(s);
  const std::unordered_map<string_t,color_t> options({
      {"sample",blue},{"extant",black},{"migration",green},
      {"node",green},{"branch",green},{"root",green}
    });
  color_t col = green;
  std::transform(copy.begin(),copy.end(),copy.begin(),
                 [](unsigned char c){return std::tolower(c);});
  try {
    col = options.at(copy);
  }
  catch (const std::out_of_range& e) {
    err("in %s: invalid metadata: type '%s' not recognized.",__func__,s.c_str());
  }
  return col;
}

Here is the caller graph for this function:

scan_name()

static name_t scan_name ( const string_t & s )

static

simple function for scanning a name_t from a string (with error trapping)

Definition at line 41 of file parse.cc.

{
  int d;
  try {
    d = stoi(s);
    if (d < 0) err("in '%s': negative deme number detected.",__func__);
  }
  catch (const std::invalid_argument& e) {
    err("in '%s': invalid Newick format: deme should be indicated with an integer.",__func__);
  }
  catch (const std::out_of_range& e) {
    err("in '%s': invalid Newick format: deme out of range.",__func__);
  }
  catch (const std::exception& e) {
    err("in '%s': parsing deme label: %s.",__func__,e.what());
  }
  catch (...) {
    err("in '%s': other deme-parsing error.",__func__);
  }
  return name_t(d);
}

Here is the caller graph for this function: