ParamsParser Class Reference

Provides interface to read input parameters from various sources and parses them. More...

#include <paramsparser.h>

Inheritance diagram for ParamsParser:

Collaboration diagram for ParamsParser:

Public Member Functions
	ParamsParser (const char *name)
virtual	~ParamsParser ()
void	setName (const char *name)
map< string, string >	get_inputParams ()
map< string, vector< string > > &	getParsedParameters (const char *stream_name)
map< string, vector< string > > &	getParsedParameters ()
map< string, string > &	getParameters (const char *stream_name)
map< string, string > &	getParameters ()
virtual bool	read (const char *stream)=0
	Read/parse params & args from a file or a string or an R object. More...
void	parse ()
	Builds the _parsedParams from the _inputParams. More...
string	replaceMacro (const string &arg)
	Macros. More...
string	parseMacroFunctionBlock (const string &in_arg)
string	callMacro (const string &name, const string &argstr)
vector< string >	getMacroArgs (const string &args, const int min_arg, const size_t max_arg, const string macro_name, const string syntax, bool lastArgIsSeparatorChar=true)
string	getMacroSepParamChar (const string &sep_in, const string macro_name)
string	getMacroParamValue (const string &str_in, const string &par_name, const string &macro_name)
string	quote (const string &argstr)
	Macro "q" returns a quoted string. More...
string	concat (const string &argstr)
	Macro "c" returns a character-delimited string of atomic arguments. More...
string	rep (const string &argstr)
string	seq (const string &argstr)
string	tempseq (const string &argstr)
string	matrix (const string &argstr)
string	diag_matrix (const string &argstr)
string	sym_matrix (const string &argstr)
string	runif (const string &argstr)
string	rnorm (const string &argstr)
string	rpoiss (const string &argstr)
string	rbernoul (const string &argstr)
string	rgamma (const string &argstr)
string	rlognorm (const string &argstr)
string	rexp (const string &argstr)

Static Public Member Functions
static void	getBlockArgument (istream &IN, char &c, string &arg)
static void	getArguments (string &arg_str, vector< string > &arg_vect)

Protected Member Functions
void	reset_inputParams ()
void	add_inputParam (string &param, const string &arg)

Private Attributes
const char *	_sname
	Attached file of stream name. More...
map< string, string >	_inputParams
	The whole, unparsed set of input parameters. More...
map< string, vector< string > >	_parsedParams
	The parsed set of simulation parameters after sequential parameters have been separated. More...
map< string, string(ParamsParser::*)(const string &)>	_macroMap
	The macro table, mapping call name to caller. More...

Detailed Description

Provides interface to read input parameters from various sources and parses them.

Constructor & Destructor Documentation

ParamsParser()

ParamsParser::ParamsParser

(

const char *

name

)

{
  _sname = name;
 
  _macroMap["rep"]      = &ParamsParser::rep;
  _macroMap["seq"]      = &ParamsParser::seq;
  _macroMap["tempseq"]  = &ParamsParser::tempseq;
  _macroMap["c"]        = &ParamsParser::concat;
  _macroMap["q"]        = &ParamsParser::quote;
  _macroMap["runif"]    = &ParamsParser::runif;
  _macroMap["rnorm"]    = &ParamsParser::rnorm;
  _macroMap["rpois"]    = &ParamsParser::rpoiss;
  _macroMap["rlognorm"] = &ParamsParser::rlognorm;
  _macroMap["rgamma"]   = &ParamsParser::rgamma;
  _macroMap["rbernoul"] = &ParamsParser::rbernoul;
  _macroMap["rexp"]     = &ParamsParser::rexp;
  _macroMap["matrix"]   = &ParamsParser::matrix;
  _macroMap["diag"]     = &ParamsParser::diag_matrix;
  _macroMap["smatrix"]  = &ParamsParser::sym_matrix;
}

References concat(), diag_matrix(), matrix(), quote(), rbernoul(), rep(), rexp(), rgamma(), rlognorm(), rnorm(), rpoiss(), runif(), seq(), sym_matrix(), and tempseq().

~ParamsParser()

virtual ParamsParser::~ParamsParser ( )

inlinevirtual

{}

Member Function Documentation

add_inputParam()

void ParamsParser::add_inputParam ( string &  param, const string &  arg  )

inlineprotected

{_inputParams[param] = arg;}

Referenced by StreamParser::read().

callMacro()

string ParamsParser::callMacro	(	const string &	name,
		const string &	argstr
	)

{
  string out;
#ifdef _DEBUG_
  message(" ^^^^ calling macro: %s(%s)\n",name.c_str(), argstr.c_str());
#endif
 
  auto elmnt = _macroMap.find(name);
 
  if( elmnt == _macroMap.end())
  {
    fatal("macro \"%s(%s)\" could not be mapped to a known function.\n", name.c_str(), argstr.c_str());
  }
 
  out = (this->*(elmnt->second))(argstr);
 
#ifdef _DEBUG_
  message(" ^^^^     returning: %s\n",out.c_str());
#endif
 
  return out;
}

References fatal(), and message().

concat()

string ParamsParser::concat

(

const string &

argstr

)

Macro "c" returns a character-delimited string of atomic arguments.

Can be passed as arguments to other macros.

{
 
  string syntax="c(... , sep=\",\")";
  string out;
 
  size_t max_arg = INT64_MAX;
 
  vector<string> macro_args = getMacroArgs(argstr, 2, max_arg, "c", syntax, true);
 
  string sep = macro_args.back();
 
  int last = macro_args.size() - 2; //omit separator at last position
 
  // stick each element together, un-quoting them, if needed
  for (int i = 0; i < last; ++i) {
    out += tstring::removeEnclosingChar(macro_args[i], '"', '"', true) + sep;
  }
  // add last element without separator
  out += tstring::removeEnclosingChar(macro_args[last], '"', '"', true);
 
 
  return out;
}

References tstring::removeEnclosingChar().

Referenced by ParamsParser().

diag_matrix()

string ParamsParser::diag_matrix

(

const string &

argstr

)

{
  string syntax = "diag(x, n)";
 
  int max_arg = 2, min_arg = 1;
  string out;
  string off_diag = "0";
  size_t nrow;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "diag", syntax, false);
 
  // the size is inferred from splitting the string provided
  vector<string> elmnts = tstring::split(tstring::removeEnclosingChar(macro_args[0], '"', '"', true), ',');
 
  if( macro_args.size() == 1) {
 
    nrow = elmnts.size();
 
  } else {
    // already checked that it's not >2 arguments passed
 
    nrow = size_t(tstring::str2uint(macro_args[1]));
 
    // the value may contain several elements that might need to be repeated:
    if(elmnts.size() > 1 && elmnts.size() != nrow) {
 
      fatal("diag(): the number of elements to use for the diag matrix is different from parameter \"n\" in: diag(%s)\n\
          use quoted rep() if you intend to repeat a pattern, eg: diag(q(rep(..., n1)),n2)\n", syntax.c_str());
 
    } else if (elmnts.size() == 1){
 
       // build the vector of elements used below
 
      for(unsigned int i = 0; i < nrow-1; ++i)
        elmnts.push_back(elmnts[0]);
    }
  }
 
  out += "{";
 
  for (unsigned int r = 0, c, e = 0; r < nrow; ++r) {
 
    out += "\n{";
 
    for (c = 0; c < nrow - 1 && e < elmnts.size(); ++c) {
 
      if(c == r)
        out += elmnts[e++] + ",";
      else
        out += off_diag + ",";
    }
 
    if(c == r)
      out += elmnts[e++] + "}";
    else
      out += off_diag + "}";
 
  }
 
  // close the matrix block
  out += "}";
 
  return out;
}

References fatal(), tstring::removeEnclosingChar(), tstring::split(), and tstring::str2uint().

Referenced by ParamsParser().

get_inputParams()

map< string, string > ParamsParser::get_inputParams ( )

inline

{return _inputParams;}

getArguments()

void ParamsParser::getArguments ( string &  arg_str, vector< string > &  arg_vect  )

static

{
  istringstream IN;
  string arg;
  int dummy_line = 0;
  char c;
  
  IN.str(arg_str);
  
  while(IN.get(c) && IN.good() && !IN.eof()){
    
    if(isspace(c)) {
      StreamParser::removeSpaceAndComment(IN, dummy_line);
      continue;
    }
    
    if(c == '{' || c == '(' || c == '[' || c == '\"')
    {
      getBlockArgument(IN, c, arg); //because it may span more than one line
    } 
    else //not a block argument
    {
      IN.putback(c);
      IN>>arg; //this stops if a whitespace is found, thus not including macro arguments if a macro
    }
 
 
    arg_vect.push_back( arg );
  }
}

References StreamParser::removeSpaceAndComment().

getBlockArgument()

void ParamsParser::getBlockArgument ( istream &  IN, char &  c, string &  arg  )

static

{
  char e = 0;
  int dummy_line = 0;
 
  switch (start_c) {
    case '{': e = '}';
      break;
    case '(': e = ')';
      break;
    case '[': e = ']';
      break;
    case '\"': e = '\"';
      break;
    default:
      break;
  }
      
  arg = StreamParser::readUntilCharacter(IN, dummy_line, start_c, (const char)e);
    
//    cout<<"added arg to vector: "<<out<<" next char='"<<IN.peek()<<"'\n";
}

References StreamParser::readUntilCharacter().

getMacroArgs()

vector< string > ParamsParser::getMacroArgs	(	const string &	args,
		const int	min_arg,
		const size_t	max_arg,
		const string	macro_name,
		const string	syntax,
		bool	lastArgIsSeparatorChar = true
	)

{
 
//  cout<<" getMacroArgs:: argstr="<<argstr<<endl;
 
  vector<string> macro_args = tstring::splitExcludeEnclosedDelimiters(argstr, ',');
 
  if(macro_args.size() > max_arg ){
    fatal("macro \"%s\" can have max %i arguments: %s\n", macro_name.c_str(), max_arg, syntax.c_str());
  }
  else if (macro_args.size() < min_arg) {
    fatal("macro \"%s\" must have at least %i arguments: %s\n", macro_name.c_str(), min_arg, syntax.c_str());
  }
 
  size_t last_arg = macro_args.size() -1;
 
  string sep = ","; // default sep
 
  // treat the last argument specially if it is a separator char
  // or add the default separator char to the arg vector if not specified in input
  if(lastArgIsSeparatorChar) {
 
    // make sure it was specified in input
    if(macro_args.size() > min_arg) {
    // check if separator is given in arg (we'll assume it is the last arg...)
       if(argstr.rfind("sep") != string::npos) {
 
        // get the separator char from the last character string
        sep = getMacroSepParamChar(macro_args[ last_arg ], macro_name);
 
        macro_args[ last_arg ] = sep; // we replace the string "sep=..." with the char
 
      } else
        macro_args.push_back(sep); //default
    } else
      macro_args.push_back(sep); //default
  }
 
//  auto print = [this](const string& s){cout<<" getMacroArgs:: "<<s<<endl;};
//
//  for_each(macro_args.cbegin(), macro_args.cend(), print);
 
  return macro_args;
}

References fatal(), and tstring::splitExcludeEnclosedDelimiters().

getMacroParamValue()

string ParamsParser::getMacroParamValue	(	const string &	str_in,
		const string &	par_name,
		const string &	macro_name
	)

{
  vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(str_in, '=');
 
  if(param_args[0] != par_name)
    fatal("expected \"%s\" as input param to macro \"%s\", received \"%s\"\n", par_name.c_str(), macro_name.c_str(), str_in.c_str());
 
  return param_args[1];
}

References fatal(), and tstring::splitExcludeEnclosedDelimiters().

getMacroSepParamChar()

string ParamsParser::getMacroSepParamChar	(	const string &	sep_in,
		const string	macro_name
	)

{
 
  if( tstring::isanumber(sep_in))
    fatal("last argument \"sep\" of macro \"%s\" must be a character string in \"%s\"\n", macro_name.c_str(), sep_in.c_str());
 
  vector<string> sep_args = tstring::splitExcludeEnclosedDelimiters(sep_in, '=');
 
  string sep;
 
  // check format of sep argument specification: sep="c", or "c"
  if(sep_args.size() == 0)
    fatal("wrong format of \"sep\" argument to macro \"%s\" in \"%s\"\n", macro_name.c_str(), sep_in.c_str());
 
  if(sep_args[0] == "sep") {
 
    if(sep_args.size() > 2){
      fatal("argument \"sep\" of macro \"%s\" must receive only one value in \"%s\" \n", macro_name.c_str(), sep_in.c_str());
    }
 
    sep = sep_args[1];
 
  } else {
    sep = sep_args[0];
  }
 
  if(sep[0] != '"') {
    fatal("argument to \"sep\" of macro \"%s\" must be enclosed with two \" in \"%s\" \n", macro_name.c_str(), sep_in.c_str());
  }
 
  sep = tstring::removeEnclosingChar(sep, '"', '"');
 
  return sep;
}

References fatal(), tstring::isanumber(), tstring::removeEnclosingChar(), and tstring::splitExcludeEnclosedDelimiters().

getParameters() [1/2]

map< string, string >& ParamsParser::getParameters ( )

inline

{return _inputParams;}

getParameters() [2/2]

map< string, string > & ParamsParser::getParameters

(

const char *

stream_name

)

{
#ifdef _DEBUG_
  cout<<"ParamsParser::getParameters:"<<endl;
#endif  
  if(stream_name == NULL) {
 
    if(_sname == NULL)
 
      fatal("ParamsParser::getParameters::no stream attached to the parser!\n");
 
    else if( !(read(_sname)) ) // read the input text stream and extract parameters and their arguments
 
      fatal("ParamsParser::getParameters::failed from file \"%s\"\n",_sname);
 
  } else if( !(read(stream_name)) )  // read the input text stream and extract parameters and their arguments
 
    fatal("ParamsParser::getParameters::failed from file \"%s\"\n",stream_name);
  
  if(stream_name != NULL) _sname = stream_name;
  
  // pairs of parameter name & values have been recorder in _inputParams map
  return _inputParams;
}

References fatal().

Referenced by BinaryDataLoader::extractPop().

getParsedParameters() [1/2]

map< string, vector< string > >& ParamsParser::getParsedParameters ( )

inline

{return _parsedParams;}

getParsedParameters() [2/2]

map< string, vector< string > > & ParamsParser::getParsedParameters

(

const char *

stream_name

)

{
#ifdef _DEBUG_
  cout<<"ParamsParser::getParsedParameters:"<<endl;
#endif  
  // read the input parameters from the input text stream
  getParameters(stream_name);
  
  // parse the input text stream
  parse();
  
  return _parsedParams;
}

Referenced by SimRunner::run().

matrix()

string ParamsParser::matrix

(

const string &

argstr

)

{
  string syntax = "matrix(x, nrow, ncol)";
 
  int max_arg = 3, min_arg = 3;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "matrix", syntax, false);
 
  if(macro_args[0][0] != '"' && macro_args[0].back() != '"')
    fatal("matrix(): first argument must be quoted with \" in: matrix(%s)\n",argstr.c_str());
 
  vector<string> elmnts = tstring::split(tstring::removeEnclosingChar(macro_args[0], '"', '"', false), ',');
 
  unsigned int nrow = tstring::str2uint(macro_args[1]);
  unsigned int ncol = tstring::str2uint(macro_args[2]);
 
  if(elmnts.size() < nrow*ncol)
    fatal("matrix(): not enough elements provided, got %i, must be rows*columns = %i\n", elmnts.size(), nrow*ncol);
 
  if(elmnts.size() > nrow*ncol)
    fatal("matrix(): too many elements provided, got %i, must be rows*columns = %i\n", elmnts.size(), nrow*ncol);
 
  // start writing the matrix into the output string
  string out("{");
 
  for (unsigned int r = 0, e = 0; r < nrow; ++r) {
 
    out += "\n{";
 
    for (unsigned int c = 0; c < ncol - 1 && e < elmnts.size(); ++c, ++e) {
 
      out += elmnts[e] + ",";
    }
 
    out += elmnts[e++] + "}";
 
  }
 
  // close the matrix block
  out += "}";
 
  return out;
}

References fatal(), tstring::removeEnclosingChar(), tstring::split(), and tstring::str2uint().

Referenced by ParamsParser().

parse()

void ParamsParser::parse

(

)

Builds the _parsedParams from the _inputParams.

This defines rules of sequential, matricial params, etc.

{
#ifdef _DEBUG_
  cout<<"ParamsParser::parse:"<<endl;
#endif  
 
  // empty container map of parameters parsed into key - value(s) pairs
  _parsedParams.clear();
  
  // local holder of the arguments read in the input stream, contains whole lines from input
  vector< string > argvect;
  string arg;
 
  // go through all parameters previously read in the input text stream and parse param values into multiple values
  map<string, string>::iterator param = _inputParams.begin();
 
  while(param != _inputParams.end()) {
 
    // first, check and replace macros:
    param->second = replaceMacro(param->second);
    
    argvect.clear();
 
    if((param->first == "stats") || (param->first == "stat") )
 
      argvect.push_back(param->second);  //this one cannot be a sequential parameter
 
    else { //other params:
 
      getArguments(param->second, argvect);
 
    }
 
    _parsedParams[param->first] = argvect;
 
#ifdef _DEBUG_
    message(" %s (", param->first.c_str());
    unsigned int nb=argvect.size()   ;
    for(unsigned int i=0 ;i<nb; ++i){
      cout<<argvect[i]<<" ";
    }
    message("| %i args)\n", nb);
#endif
 
    param++;
  }
}

References message().

parseMacroFunctionBlock()

string ParamsParser::parseMacroFunctionBlock

(

const string &

in_arg

)

{
  string front, tail, rest, out_arg;
  string name;
 
//  cout<<"parseMacroFunctionBlock <"<< in_arg <<">\n";
 
  size_t opar_pos, cpar_pos, first_macro_ch;
 
  // extract the name of the macro, first find the opening parenthesis
  opar_pos = in_arg.find_first_of('(', 1);
 
  //cut the string at the opening par to look for the macro name in the front part
  front = in_arg.substr(0, opar_pos);
 
  //cut the string after the opening par to look for macro arguments and more macros in the rest
  rest = in_arg.substr(opar_pos+1,  in_arg.size() - opar_pos - 1);
 
  //a macro name can only start after the last delimiter in front of it
  first_macro_ch = front.find_last_of("(){}[], =\t");
  // '=' is included because arguments to macros can be named and assigned a call to a nested macro
  // eg: tempseq(at=seq(),seq=seq())
 
  //the open par may not be part of a macro, or there might not be any delim in front, check this:
  if(first_macro_ch == string::npos)
    first_macro_ch = 0; // no delim before name, start at first pos in string
  else
    first_macro_ch++;  //skip the last delimiter
 
  // check if we have a macro name in front and extract it
  if(opar_pos > first_macro_ch)
  {
    name = in_arg.substr(first_macro_ch, opar_pos - first_macro_ch);
    // keep what was in front of the macro name;
    front = in_arg.substr(0, first_macro_ch);
  }
  else // first_macro_ch == opar_pos; no name, no macro, skip
  {    // this corresponds to cases where multiple blocks are provided in input:
       // param_name (... macro1(...),...) (... macro2(...), ...)
       // the second block causes problems if we lose the brackets on the way
 
    name = "";
 
    // keep what was in front of the false macro block, including the opening '(';
    front = in_arg.substr(0, first_macro_ch+1);
  }
 
  out_arg += front;
 
  // before reading the arguments of the macro function call, check for nested macros, recursively
  if(rest.find_first_of('(', 1) != string::npos)
  {
    //recursion
    //replace the macro name by the result of the call to the nested macro in the macro_args vect
    rest = ( parseMacroFunctionBlock(rest) );
 
  }
  //no more nested block, close recursion and return arguments
 
//  cout<< " processing: "<<rest<<endl;
 
  // find the limit of the  macro args
  cpar_pos = rest.find_first_of(')');
 
  if ( cpar_pos != string::npos)
  {
    // record what is left after the macro args, excluding the closing macro ')'
    if( cpar_pos < rest.size()-1 ){
 
      tail = rest.substr(cpar_pos+1, rest.size() - cpar_pos - 1);
    }
    else
      tail = "";
  }
  else
  {
    fatal("Error while parsing argument string \"%s\" for macros, closing bracket not found\n", (rest+tail).c_str());
  }
 
  rest = rest.substr(0, cpar_pos); // this is the string containing the args to the macro
 
  if(name == "")
  {
 
//    cout<< " not calling macro: name =\"\"; arg string is <"<<rest<<">"<<"\n";
 
    out_arg += rest +")" + tail; //need to put back the closing ')' because not a macro
 
  }
  else
  {
 
//    cout<< " calling macro: "<<name<<"("<<rest<<")"<<"\n";
 
    // call the macro and paste the result into the output string
    out_arg += callMacro(name, rest) + tail;
 
  }
 
//  cout<< "   returning "<<out_arg<<endl;
  // return the processed string
  return out_arg;
}

References fatal().

quote()

string ParamsParser::quote

(

const string &

argstr

)

Macro "q" returns a quoted string.

Useful to quote result of call to enclosed macro.

{
 
  string syntax="q(... , sep=\",\")";
  string out;
 
  size_t max_arg = INT64_MAX;
 
  vector<string> macro_args = getMacroArgs(argstr, 1, max_arg, "q", syntax, true);
 
  string sep = macro_args.back();
 
  int last = macro_args.size() - 2; //omit separator at last position
 
  for (int i = 0; i < last; ++i) {
    out += macro_args[i] + sep;
  }
  // add last element without separator
  out += macro_args[last];
 
  return "\"" + out + "\"";
}

Referenced by ParamsParser().

rbernoul()

string ParamsParser::rbernoul

(

const string &

argstr

)

{
  string syntax = "rbernoul(n, p=0.5, sep=\",\")";
 
  int max_arg = 3, min_arg = 1;
  double p = 0.5;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rbernoul", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rbernoul(): first argument must be a positive integer in: rbernoul(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rbernoul(): first argument must be a positive integer in: rbernoul(%s)\n", argstr.c_str());
 
 
  // get the mean value, if present
  // we omit last arg macro_args[2] which is always the separator character
  if(macro_args.size() == 3){
 
    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[1], '=');
 
    if(param_args[0] == "p") {
 
      p = tstring::str2dble(param_args[1]);
 
    } else if(param_args.size() == 1) {
 
      // the string "mean=" can be omitted by user
 
      p = tstring::str2dble(param_args[0]);
 
    } else {
 
      fatal("rbernoul() syntax is: %s\n",syntax.c_str());
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [p](){return tstring::int2str(RAND::Bernoulli(p));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References RAND::Bernoulli(), fatal(), tstring::int2str(), tstring::isanumber(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

read()

virtual bool ParamsParser::read ( const char *  stream )

pure virtual

Read/parse params & args from a file or a string or an R object.

Params and their args are put in the _inputParams.

Implemented in StreamParser, BinaryFileParser, and FileParser.

rep()

string ParamsParser::rep

(

const string &

argstr

)

{
 
  string syntax="rep(x, n, each=1, sep=\",\")";
 
  int max_arg = 4;
 
  vector<string> macro_args = getMacroArgs(argstr, 2, max_arg, "rep", syntax, true);
 
//  auto print = [this](const string& s){cout<<" "<<s<<endl;};
//
//  for_each(macro_args.cbegin(), macro_args.cend(), print);
 
  auto num_args = macro_args.size();
 
  // ---- get the string to repeat ----
  string what = macro_args[0];
 
  //removing enclosing "" if added:
  what = tstring::removeEnclosingChar(what, '"', '"', true);
 
  // ---- the second argument is the number of repetition ----
  if ( !tstring::isanumber(macro_args[1]) ) {
    fatal("rep(): second argument must be a number in: rep(x, n, each=1, sep=\",\")\n");
  }
 
  int num = tstring::str2int(macro_args[1]);
 
  // ---- looking for the "each" argument ----
  auto has_each = [] (const string& s) {return (s.find("each") != string::npos);};
 
  auto argPos = find_if(macro_args.begin(), macro_args.end(), has_each);
 
  string arg;
 
  if( argPos != macro_args.end() )
    arg = getMacroParamValue(*argPos, "each", syntax);
  else
    arg = "1";  // default value if argument is absent, mean "each" must be named
 
  int each = tstring::str2int(arg);
 
  // the separator char has been set at the back by default
  string sep;
 
  sep = macro_args[num_args-1];
 
 
  // processing the input in case where "each" has been specified
  vector<string> elmnts;
 
  if(argPos != macro_args.end())
    elmnts  = tstring::split(tstring::removeEnclosingChar(macro_args[0], '"', '"', true), ',');
  else
    elmnts.push_back(what);
 
  string out;
 
  for(int i = 0; i < num; ++i) {
    for(auto e = 0; e < elmnts.size(); ++e) {
      for(int j = 0; j < each; ++j) {
        out += elmnts[e] + sep;
      }
    }
  }
  // remove last separator, only if more than one element was concatenated
  if(sep == ",")
    out = tstring::removeLastCharOf(out, ',');
 
  return out;
}

References fatal(), tstring::isanumber(), tstring::removeEnclosingChar(), tstring::removeLastCharOf(), tstring::split(), and tstring::str2int().

Referenced by ParamsParser().

replaceMacro()

string ParamsParser::replaceMacro

(

const string &

arg

)

Macros.

{
  // we now need to check if a macro is part of the argument string
  // this is detected if the arg string holds a "(" as in "macro_name( "
  // or "(" is within the whole string as in "macro_name(arg1"
  // or "(" is within a block argument, we skip the first char to account for that last case
 
  string out_arg;
 
  if( arg.find_first_of('(', 1) != string::npos )
  {
    // there might be a macro, get it
 
    out_arg = parseMacroFunctionBlock(arg);
 
  }
  else  // no macro
  {
    out_arg = arg;
  }
 
  return out_arg;
}

reset_inputParams()

void ParamsParser::reset_inputParams ( )

inlineprotected

{_inputParams.clear();}

Referenced by StreamParser::read().

rexp()

string ParamsParser::rexp

(

const string &

argstr

)

{
  string syntax = "rexp(n, mean=1, sep=\",\")";
 
  int max_arg = 3, min_arg = 1;
  double mean=1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rexp", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rexp(): first argument must be a positive integer in: rexp(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rexp(): first argument must be a positive integer in: rexp(%s)\n", argstr.c_str());
 
 
  // get the mean value, if present
  // we omit last arg macro_args[2] which is always the separator character
  if(macro_args.size() == 3){
 
    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[1], '=');
 
    if(param_args[0] == "mean") {
 
      mean = tstring::str2dble(param_args[1]);
 
    } else if(param_args.size() == 1) {
 
      // the string "mean=" can be omitted by user
 
      mean = tstring::str2dble(param_args[0]);
 
    } else {
 
      fatal("rexp() syntax is: %s\n",syntax.c_str());
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [mean](){return tstring::dble2str(RAND::Exponential(mean));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), RAND::Exponential(), fatal(), tstring::isanumber(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

rgamma()

string ParamsParser::rgamma

(

const string &

argstr

)

{
  string syntax = "rgamma(n, a, b, sep=\",\")";
 
  // a and b params are mandatory, with no default
 
  int max_arg = 4, min_arg = 3;
  double a = 0.0, b = 1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rgamma", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rgamma(): first argument must be a positive integer in: rgamma(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rgamma(): first argument must be a positive integer in: rgamma(%s)\n", argstr.c_str());
 
 
  // omit last arg which is always the separator character
 
  for (unsigned int i = 1; i < macro_args.size()-1; ++i) {
 
    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[i], '=');
 
    if(param_args[0] == "a") {
 
      a = tstring::str2dble(param_args[1]);
 
    } else if(param_args[0] == "b") {
 
      b = tstring::str2dble(param_args[1]);
 
    } else if(param_args.size() == 1) {
 
      // the strings "a=" or "b=" can be omitted by the user
      // we assume meaning by position
 
      if(i == 1)
        a = tstring::str2dble(param_args[0]);
      else if (i == 2)
        b = tstring::str2dble(param_args[0]);
 
    } else {
 
      fatal("rgamma() syntax is: %s.\n",syntax.c_str());
    }
  }
 
  if(a < 0)
    fatal("rgamma(): shape parameter \"a\" must be positive in %s.\n",syntax.c_str());
 
  if(b < 0)
    fatal("rgamma(): rate parameter \"b\" must be positive in %s.\n",syntax.c_str());
 
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [a, b](){return tstring::dble2str(RAND::Gamma(a,b));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), fatal(), RAND::Gamma(), tstring::isanumber(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

rlognorm()

string ParamsParser::rlognorm

(

const string &

argstr

)

{
  string syntax = "rlognorm(n, mean, sd, sep=\",\")";
 
  // a and b params are mandatory, with no default
 
  int max_arg = 4, min_arg = 3;
  double a = 0.0, b = 1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rlognorm", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rlognorm(): first argument must be a positive integer in: rlognorm(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rlognorm(): first argument must be a positive integer in: rlognorm(%s)\n", argstr.c_str());
 
 
  // omit last arg which is always the separator character
 
  for (unsigned int i = 1; i < macro_args.size()-1; ++i) {
 
    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[i], '=');
 
    if(param_args[0] == "mean") {
 
      a = tstring::str2dble(param_args[1]);
 
    } else if(param_args[0] == "sd") {
 
      b = tstring::str2dble(param_args[1]);
 
    } else if(param_args.size() == 1) {
 
      // the strings "mean=" or "sd=" can be omitted by the user
      // we assume meaning by position
 
      if(i == 1)
        a = tstring::str2dble(param_args[0]);
      else if (i == 2)
        b = tstring::str2dble(param_args[0]);
 
    } else {
 
      fatal("rlognorm() syntax is: %s\n",syntax.c_str());
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [a, b](){return tstring::dble2str(RAND::LogNormal(a,b));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), fatal(), tstring::isanumber(), RAND::LogNormal(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

rnorm()

string ParamsParser::rnorm

(

const string &

argstr

)

{
  string syntax = "rnorm(n, mean=0, sd=1, sep=\",\")";
 
  int max_arg = 4, min_arg = 1;
  double mean = 0.0, sd = 1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rnorm", syntax, true);
 
 
//    auto print = [this](const string& s){cout<<" getMacroArgs:: "<<s<<endl;};
//
//    for_each(macro_args.cbegin(), macro_args.cend(), print);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rnorm(): first argument must be a positive integer in: rnorm(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rnorm(): first argument must be a positive integer in: rnorm(%s)\n", argstr.c_str());
 
  // get the mean and sd values, if present
  if(macro_args.size()-1 > 1){
 
    // omit last arg which is always the separator character
 
    for (unsigned int i = 1; i < macro_args.size()-1; ++i) {
 
      vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[i], '=');
 
      if(param_args[0] == "mean") {
 
        mean = tstring::str2dble(param_args[1]);
 
      } else if(param_args[0] == "sd") {
 
        sd = tstring::str2dble(param_args[1]);
 
      } else if(param_args.size() == 1) {
 
        // the "mean=" and "sd=" can be omitted
 
        if(i == 1)
          mean = tstring::str2dble(param_args[0]);
        else if (i == 2)
          sd = tstring::str2dble(param_args[0]);
 
      } else {
 
        fatal("rnorm() syntax is: %s\n",syntax.c_str());
      }
 
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
  auto draw = [mean, sd](){return tstring::dble2str(mean + RAND::Gaussian(sd));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), fatal(), RAND::Gaussian(), tstring::isanumber(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

rpoiss()

string ParamsParser::rpoiss

(

const string &

argstr

)

{
  string syntax = "rpois(n, mean=1, sep=\",\")";
 
  int max_arg = 3, min_arg = 1;
  double mean = 1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "rpois", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("rpois(): first argument must be a positive integer in: rpois(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("rpois(): first argument must be a positive integer in: rpois(%s)\n", argstr.c_str());
 
 
  // get the mean value, if present
  // we omit last arg macro_args[2] which is always the separator character
  if(macro_args.size() == 3){
 
    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[1], '=');
 
    if(param_args[0] == "mean") {
 
      mean = tstring::str2dble(param_args[1]);
 
    } else if(param_args.size() == 1) {
 
      // the string "mean=" can be omitted by user
 
      mean = tstring::str2dble(param_args[0]);
 
    } else {
 
      fatal("rpois() syntax is: %s\n",syntax.c_str());
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [mean](){return tstring::dble2str(RAND::Poisson(mean));};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), fatal(), tstring::isanumber(), RAND::Poisson(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), and tstring::str2uint().

Referenced by ParamsParser().

runif()

string ParamsParser::runif

(

const string &

argstr

)

{
  string syntax = "runif(n, min=0, max=1, sep=\",\")";
 
  int max_arg = 4, min_arg = 1;
  double min = 0.0, max = 1.0;
  unsigned int num_deviates;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "runif", syntax, true);
 
  // get and check the number of deviates we need to draw
  if(!tstring::isanumber(macro_args[0]))
    fatal("runif(): first argument must be a positive integer in: runif(%s)\n", argstr.c_str());
 
  num_deviates = tstring::str2uint(macro_args[0]);
 
  if(!(num_deviates > 0))
    fatal("runif(): first argument must be a positive integer in: runif(%s)\n", argstr.c_str());
 
 
//  map<string, double> dev_param; dev_param["min"] = 0.0; dev_param["max"] = 1.0;
//
//  auto get_param_value = [&](const string& str_in){
//    vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(str_in, '=');
//
//  };
 
  // get the min and max values, if present
  if(macro_args.size()-1 > 1){
 
    // omit last arg which is always the separator character
 
    for (unsigned int i = 1; i < macro_args.size()-1; ++i) {
 
      vector<string> param_args = tstring::splitExcludeEnclosedDelimiters(macro_args[i], '=');
 
      if(param_args[0] == "min") {
 
        min = tstring::str2dble(param_args[1]);
 
      } else if(param_args[0] == "max") {
 
        max = tstring::str2dble(param_args[1]);
 
      } else if(param_args.size() == 1) {
 
        // the "min=" and "max=" can be omitted
 
        if(i == 1)
          min = tstring::str2dble(param_args[0]);
        else if (i == 2)
          max = tstring::str2dble(param_args[0]);
 
      }else {
 
        fatal("runif() syntax is: %s\n",syntax.c_str());
      }
    }
  }
 
  string sep = macro_args.back();
 
  // compute the random deviates
  string out;
 
  auto draw = [min, max](){return tstring::dble2str((max-min)*RAND::Uniform() + min);};
 
  for(unsigned int i = 0; i < num_deviates -1; ++i)
    out += draw() + sep;
 
  out += draw();
 
  return out;
}

References tstring::dble2str(), fatal(), tstring::isanumber(), tstring::splitExcludeEnclosedDelimiters(), tstring::str2dble(), tstring::str2uint(), and RAND::Uniform().

Referenced by ParamsParser().

seq()

string ParamsParser::seq

(

const string &

argstr

)

{
  string syntax="seq(from, to, by, sep=\",\")";
 
  int max_arg = 4;
 
  vector<string> macro_args = getMacroArgs(argstr, 3, max_arg, "seq", syntax, true);
 
  string sep = macro_args[ 3 ];
 
  for (int i = 0; i < 3; ++i) {
 
    if(!tstring::isanumber(macro_args[i]))
      fatal("seq(): argument %i must be a number in: seq(%s)\n", i+1, argstr.c_str());
 
  }
 
  // now create the sequence of numbers:
  string out;
 
  int index = 0;
  double current = tstring::str2dble(macro_args[0]);
  double to = tstring::str2dble(macro_args[1]);
  double i = tstring::str2dble(macro_args[2]);
 
  double sign = 1.0; // indicate whether the sequence is increasing (+1.0) or decreasing (-1.0)
 
  // check if the sequence is decreasing
  if(current > to) {
 
    sign = -1.0;
 
    if(i > 0)
      fatal("seq(): third argument \"by\" must be a negative number when from > to in: seq(%s).\n", argstr.c_str());
 
//      i *= sign; // must be negative when decrement
  }
 
  // check the sign of the increment if increasing sequence
  if(current < to && i < 0) {
 
    fatal("seq(): third argument \"by\" must be a positive number when from < to in: seq(%s).\n", argstr.c_str());
 
//    i *= -1.0; //make it positive
  }
  // loop until reaching "to"
  while(sign*(current-to) < 1.0e-15) { // to avoid precision errors, it's a workaround, setting epsilon to a fixed value
 
    out += tstring::dble2str(current);
 
    current += i;
 
    // check next value to place the separator thus avoiding adding a separator after the last value
    if(sign*(current-to) < 1.0e-15)
      out += sep;
  };
 
  return out;
}

References tstring::dble2str(), fatal(), tstring::isanumber(), and tstring::str2dble().

Referenced by ParamsParser().

setName()

void ParamsParser::setName ( const char *  name )

inline

{_sname = name;}

Referenced by BinaryDataLoader::extractPop().

sym_matrix()

string ParamsParser::sym_matrix

(

const string &

argstr

)

{
  string syntax = "smatrix(x, nrow, diag=0)";
 
  // first arg is row-oriented
  int max_arg = 3, min_arg = 2;
  string out;
  size_t nrow;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "smatrix", syntax, false);
 
  // the size is inferred from splitting the string provided
  vector<string> upper = tstring::split(tstring::removeEnclosingChar(macro_args[0], '"', '"', true), ',');
 
  if(!tstring::isanumber(macro_args[1]))
    fatal("smatrix(): secong argument \"nrow\" is not a number in: smatrix(%s)\n", argstr.c_str());
  else
    nrow = tstring::str2int(macro_args[1]);
 
  size_t num_el = nrow*(nrow-1)/2;
 
  //fill "upper" if only one value was passed, that value will be copied
  if( upper.size() == 1) {
    string val = upper[0];
    upper.assign(num_el, val);
  }
 
  // check size
  if( upper.size() != nrow*(nrow-1)/2 )
    fatal("smatrix(): number of elements (%i) passed doesn't match with the number of rows (%i) specified in: smatrix(%s)\n", upper.size(), nrow, argstr.c_str());
 
  // look for diagonal elements
  auto is_diag = [] (const string& s) {return (s.find("diag") != string::npos);};
 
  vector<string>::const_iterator diagPos = find_if(macro_args.begin(), macro_args.end(), is_diag);
 
  vector<string> diag;
  string diag_arg;
 
  if( diagPos != macro_args.end() ) // user specified the diagonal elements
  {
    diag_arg = *diagPos;
    //remove the front string "diag=" and get the argument value
    diag_arg = getMacroParamValue(diag_arg, "diag", syntax);
 
    diag = tstring::split(tstring::removeEnclosingChar(diag_arg, '"', '"', true), ',');
 
    if(diag.size() == 1) {
      string val = diag[0];
      diag.assign(nrow, val);
    }
    else if (diag.size() != nrow) {
      fatal("smatrix(): number of elements to \"diag\" doesn't match with the matrix size in: smatrix(%s)\n", argstr.c_str());
    }
 
  } else
    diag.assign(nrow, "0");
 
  // create the matrix
 
  TMatrix mat(nrow, nrow);
 
  for (unsigned int r = 0, c, e = 0, d = 0; r < nrow ; ++r) {
 
    for (c = r; c < nrow && e < upper.size(); ++c) {
 
      if(c == r)
        mat.set(r, c, tstring::str2dble(diag[d++]));
      else
        mat.set(r, c, tstring::str2dble(upper[e++]));
    }
 
    // catch the last diagonal element of the matrix, after having copied all off-diagonal elements
    if(c == r)
      mat.set(r, c, tstring::str2dble(diag[d++]));
  }
 
  // fill the lower triangle:
  for (unsigned int r = nrow-1; r > 0 ; --r) {
 
    for(unsigned int c = 0; c < r; ++c)
 
      mat.set(r, c, mat.get(c,r));
 
  }
 
  return mat.to_string();
}

References fatal(), TMatrix::get(), tstring::isanumber(), tstring::removeEnclosingChar(), TMatrix::set(), tstring::split(), tstring::str2dble(), tstring::str2int(), and TMatrix::to_string().

Referenced by ParamsParser().

tempseq()

string ParamsParser::tempseq

(

const string &

argstr

)

{
  string syntax = "tempseq(at, seq) ";
 
  int max_arg = 2, min_arg = 2;
 
  vector<string> macro_args = getMacroArgs(argstr, min_arg, max_arg, "tempseq", syntax, false);
 
  //get arg values by name:
  string arg;
  vector<string>::const_iterator argPos;
 
 
  // look for a named argument
 
  // check if arg "at" is named ( at="..." )
  auto has_at = [] (const string& s) {return (s.find("at") != string::npos);};
 
  argPos = find_if(macro_args.begin(), macro_args.end(), has_at);
 
  if( argPos != macro_args.end() )
    arg = getMacroParamValue(*argPos, "at", syntax);
  else
    arg = macro_args[0];  // default assignment by position
 
  vector<string> at_time = tstring::split(tstring::removeEnclosingChar(arg, '"', '"', false), ',');
 
  if(at_time[0] != "0")
    fatal("tempseq(): argument \"at\" must start with value \'0\' (for parameter's initial value at generation 0) in: tempseq(%s).\n",argstr.c_str());
 
  // check if arg "seq" is named:
  auto has_seq = [] (const string& s) {return (s.find("seq") != string::npos);};
 
  argPos = find_if(macro_args.begin(), macro_args.end(), has_seq);
 
  if( argPos != macro_args.end() )
    arg = getMacroParamValue(*argPos, "seq", syntax);
  else
    arg = macro_args[1];  // default assignment by position
 
  vector<string> values = tstring::split(tstring::removeEnclosingChar(arg, '"', '"', false), ',');
 
  //------- process input and build output string ---------
  size_t num_gen = at_time.size();
  size_t num_val = values.size();
 
  if(num_val < num_gen)
    fatal("tempseq(): argument \"seq\" contains less values than \"at\" in: tempseq(%s).\n",argstr.c_str());
 
  if(num_val > num_gen)
    fatal("tempseq(): argument \"seq\" contains more values than \"at\" in: tempseq(%s)\n",argstr.c_str());
 
  string out = "(";
 
  for(auto i = 0; i < num_gen-1; ++i) {
 
    out += "@g" + at_time[i] + " " + values[ i % num_val] + ", ";
  }
 
  out += "@g" + at_time[num_gen-1] + " " + values[ (num_gen-1) % num_val] + ")";
 
  return out;
}

References fatal(), tstring::removeEnclosingChar(), and tstring::split().

Referenced by ParamsParser().

Member Data Documentation

_inputParams

map< string, string > ParamsParser::_inputParams

private

The whole, unparsed set of input parameters.

_macroMap

map< string, string (ParamsParser::* )(const string& )> ParamsParser::_macroMap

private

The macro table, mapping call name to caller.

_parsedParams

map< string, vector< string > > ParamsParser::_parsedParams

private

The parsed set of simulation parameters after sequential parameters have been separated.

_sname

const char* ParamsParser::_sname

private

Attached file of stream name.

---

The documentation for this class was generated from the following files:

• paramsparser.h
• paramsparser.cc