Configurator Class Reference

A class to provide standard parameter entry facilities. More...

#include <Configurator.h>

Public Member Functions
void	SetCfgInt (std::string a_key, std::string a_val)
void	SetCfgFloat (std::string a_key, std::string a_val)
void	SetCfgBool (std::string a_key, std::string a_val)
void	SetCfgStr (std::string a_key, std::string a_val)
void	SetCfgArrayInt (std::string a_key, std::string a_val)
void	SetCfgArrayDouble (std::string a_key, std::string a_val)
void	SetCfgArrayIntCsv (std::string a_key, std::string a_val)
void	SetCfgArrayDoubleCsv (std::string a_key, std::string a_val)
void	SetCfgFunction (std::string a_key, std::string a_val)
void	DumpPublicSymbols (const char *a_dumpfile, CfgSecureLevel a_level)
void	DumpAllSymbolsAndExit (const char *a_dumpfile)
bool	ReadSymbols (const char *a_cfgfile)
	Configurator (void)
	~Configurator (void)
bool	Register (CfgBase *a_cfgval, const std::string &a_key)
bool	Register (std::shared_ptr< CfgBase > a_cfgval, const std::string &a_key)
void	StoreFromConfig (const std::string &name, std::string type, std::string value)
bool	CheckBounds (std::shared_ptr< CfgBase > a_cfgval, CfgBase *b_cfgval)
std::vector< int >	ParseArrayInt (const std::string &a_stringtoparse)
std::vector< double >	ParseArrayDouble (const std::string &a_stringtoparse)

Protected Member Functions
bool	ParseCfgLine (std::string a_line)
bool	SetCfgGatekeeper (const std::string a_method, const std::string a_key, CfgSecureLevel a_level)
void	ShowIdType (unsigned int a_i)
std::string	ExtractString (std::string a_line) const
bool	ParseCommentLine (std::string a_line)
	Reads each line and parses it. More...
void	DumpSymbols (const char *a_dumpfile, CfgSecureLevel a_level)

Protected Attributes
std::map< std::string, unsigned int >	CfgI
std::vector< std::shared_ptr< CfgBase > >	CfgVals
unsigned int	m_lineno

Detailed Description

A class to provide standard parameter entry facilities.

Constructor & Destructor Documentation

Configurator()

Configurator::Configurator

(

void

)

{
    m_lineno = 0;
}

References m_lineno.

~Configurator()

Configurator::~Configurator

(

void

)

{
  ;
}

Member Function Documentation

CheckBounds()

bool Configurator::CheckBounds	(	std::shared_ptr< CfgBase >	a_cfgval,
		CfgBase *	b_cfgval
	)

Function checks that values in the configfile a_cfgval and in the var b_cfgval are in line

                                                                                {
     if (b_cfgval->gettype()!=a_cfgval->gettype()){
        g_msg->Warn( WARN_FILE, "Configurator::CheckBounds() "
        "Mismatched config variable types",
        "NA" );
        return false;
     }
    switch (b_cfgval->gettype()) {
            case CFG_INT:{
            if ((b_cfgval->get_rangetest())&&(std::dynamic_pointer_cast<CfgInt>(a_cfgval)->value()>dynamic_cast<CfgInt*>(b_cfgval)->getmax()
            ||std::dynamic_pointer_cast<CfgInt>(a_cfgval)->value()<dynamic_cast<CfgInt*>(b_cfgval)->getmin())){
                g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\n Check failed "
                                        +std::dynamic_pointer_cast<CfgInt>(a_cfgval)->getkey()+" Not within the bounds, setting default",
                "NA" );
#ifdef __CFG_RUNNING_DEFAULTS
                std::dynamic_pointer_cast<CfgInt>(a_cfgval)->set(dynamic_cast<CfgInt*>(b_cfgval)->value());
#endif
            }else{
                dynamic_cast<CfgInt*>(b_cfgval)->set(std::dynamic_pointer_cast<CfgInt>(a_cfgval)->value());
                // g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                //                         +std::dynamic_pointer_cast<CfgInt>(a_cfgval)->getkey()+": Using config file value "
                //                                " Line: ", "NA");
            }
 
            };
            break;
            case CFG_FLOAT: {
                if ((b_cfgval->get_rangetest())&&(std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->value() >
                    dynamic_cast<CfgFloat *>(b_cfgval)->getmax()
                    || std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->value() <
                       dynamic_cast<CfgFloat *>(b_cfgval)->getmin())) {
                    g_msg->Warn(WARN_FILE, "Configurator::CheckBounds()\n Check failed"
                                           + std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->getkey() +
                                           "Not within the bounds, setting default", "NA"
                    );
#ifdef __CFG_RUNNING_DEFAULTS
                    std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->set(dynamic_cast<CfgFloat*>(b_cfgval)->value());
#endif
                } else {
                    dynamic_cast<CfgFloat *>(b_cfgval)->set(std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->value());
                    // g_msg->Warn(WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                    //                        + std::dynamic_pointer_cast<CfgFloat>(a_cfgval)->getkey() +
                    //                        ": Using config file value "
                    //                        "Line: ", "NA");
                }
            }
            break;
            case CFG_BOOL:{
                dynamic_cast<CfgBool*>(b_cfgval)->set(std::dynamic_pointer_cast<CfgBool>(a_cfgval)->value());
                // g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                //                         +std::dynamic_pointer_cast<CfgBool>(a_cfgval)->getkey()+": Using config file value "
                //                                                                                "Line: ", "NA");
            }
            break;
            case CFG_STRING:{
                 dynamic_cast<CfgStr*>(b_cfgval)->set(std::dynamic_pointer_cast<CfgStr>(a_cfgval)->value());
                // g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                //                         +std::dynamic_pointer_cast<CfgStr>(a_cfgval)->getkey()+": Using config file value "
                //                                                                                "Line: ", "NA");
            }
                break;
                case CFG_ARRAY_INT:{
                    if(std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->get_array_size()!=dynamic_cast<CfgArray_Int*>(b_cfgval)->get_array_size())
                        if (dynamic_cast<CfgArray_Int*>(b_cfgval)->value().empty()){
                            g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck failed wrong vector size "
                                                    +std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->getkey()+": No in-code value "
                                                                                                           "Line: ", "NA");
                            return false;
                        }
                        else{
                            g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck failed wrong vector size "
                                                    +std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->getkey()+": Using in-code value "
                                                                                                                 "Line: ", "NA");
#ifdef __CFG_RUNNING_DEFAULTS
                            std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->set(dynamic_cast<CfgArray_Int*>(b_cfgval)->value());
#endif
                    }
                        else{
                            dynamic_cast<CfgArray_Int*>(b_cfgval)->set(std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->value());
                            // g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                            //                     +std::dynamic_pointer_cast<CfgArray_Int>(a_cfgval)->getkey()+": Using config file value "
                            //                                                                            "Line: ", "NA");
                        }
                }
                break;
                case CFG_ARRAY_DOUBLE:{
                    if(std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->get_array_size()!=dynamic_cast<CfgArray_Double*>(b_cfgval)->get_array_size())
                        if (dynamic_cast<CfgArray_Double*>(b_cfgval)->value().empty()){
                            g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck failed wrong vector size "
                                                    +std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->getkey()+": No in-code value "
                                                                                                                 "Line: ", "NA");
                            return false;
                        }
                        else{
                            g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck failed wrong vector size "
                                                    +std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->getkey()+": Using in-code value "
                                                                                                                 "Line: ", "NA");
#ifdef __CFG_RUNNING_DEFAULTS
                            std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->set(dynamic_cast<CfgArray_Double*>(b_cfgval)->value());
#endif
                        }
                    else{
                        dynamic_cast<CfgArray_Double*>(b_cfgval)->set(std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->value());
                        // g_msg->Warn( WARN_FILE, "Configurator::CheckBounds()\nCheck passed "
                        //                         +std::dynamic_pointer_cast<CfgArray_Double>(a_cfgval)->getkey()+": Using config file value "
                        //                                                                                      "Line: ", "NA");
                    }
                }
                break;
 
}
return true;
}

References CFG_ARRAY_DOUBLE, CFG_ARRAY_INT, CFG_BOOL, CFG_FLOAT, CFG_INT, CFG_STRING, g_msg, CfgBase::get_rangetest(), CfgBase::gettype(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by Register().

DumpAllSymbolsAndExit()

void Configurator::DumpAllSymbolsAndExit

(

const char *

a_dumpfile

)

{
  DumpSymbols( a_dumpfile, CFG_PRIVATE );
  exit(1);
}

References CFG_PRIVATE, and DumpSymbols().

DumpPublicSymbols()

void Configurator::DumpPublicSymbols	(	const char *	a_dumpfile,
		CfgSecureLevel	a_level
	)

{
  if ( a_level > CFG_PUBLIC ) {
    a_level = CFG_PUBLIC;
  }
  DumpSymbols( a_dumpfile, a_level );
}

References CFG_PUBLIC, and DumpSymbols().

DumpSymbols()

void Configurator::DumpSymbols ( const char *  a_dumpfile, CfgSecureLevel  a_level  )

protected

{
  FILE *l_dumpfile;
  char l_oprefix[ CFG_MAX_LINE_LENGTH ] = {""};
  char l_nprefix[ CFG_MAX_LINE_LENGTH ];
  std::string l_id;
  l_dumpfile=fopen( a_dumpfile, "w" );
  if (!l_dumpfile) {
    g_msg->Warn( WARN_FILE, "Configurator::DumpSymbols() "
         "Unable to open file for writing:",
         a_dumpfile );
    exit(1);
  }
 
  typedef std::map<std::string,unsigned int>::const_iterator MI;
 
  for ( MI ii = CfgI.begin(); ii != CfgI.end(); ii++ ) {
    unsigned int i = ii->second;
 
    // Skip 'secret' variables.
    if ( (CfgVals[ i ].get())->getlevel() > a_level ) {
      continue;
    }
 
    // Weird hack to separate different groups of
    // configuration names.
    std::string rubbish=(CfgVals[ i ].get())->getkey();
    l_id=rubbish.c_str();
    //l_id = (CfgVals[ i ].get())->getkey().c_str();
    sscanf( l_id.c_str(), "%[A-Z]", l_nprefix );
    if ( strcmp( l_oprefix, l_nprefix ) != 0 ) {
      fprintf( l_dumpfile, "\n" );
      strcpy( l_oprefix, l_nprefix );
    }
 
    fprintf( l_dumpfile, "%s (%s) = ",
         l_id.c_str(),
         CfgTypeStrings[ (CfgVals[ i ].get())->gettype() ].c_str()
         );
 
    switch( (CfgVals[ i ].get())->gettype() ) {
    case CFG_INT:
      {
    CfgInt* l_p = dynamic_cast<CfgInt*>((CfgVals[ i ].get()));
    fprintf( l_dumpfile, "%d", l_p->value() );
    break;
      }
    case CFG_FLOAT:
      {
    CfgFloat* l_p = dynamic_cast<CfgFloat*>((CfgVals[ i ].get()));
    fprintf( l_dumpfile, "%f", l_p->value() );
    break;
      }
    case CFG_BOOL:
      {
    CfgBool* l_p = dynamic_cast<CfgBool*>((CfgVals[ i ].get()));
    if ( l_p->value() ) {
      fprintf( l_dumpfile, "true" );
    } else {
      fprintf( l_dumpfile, "false" );
    }
    break;
      }
    case CFG_STRING:
      {
    CfgStr* l_p = dynamic_cast<CfgStr*>((CfgVals[ i ].get()));
    fprintf( l_dumpfile, "\"%s\"", l_p->value() );
    break;
      }
     case CFG_ARRAY_INT:
         {
         CfgArray_Int *l_p = dynamic_cast<CfgArray_Int *>((CfgVals[i].get()));
         std::ostringstream oss;
         auto mystring= l_p->value();
            if (!mystring.empty())
            {
            // Convert all but the last element to avoid a trailing " "
                std::copy(mystring.begin(), mystring.end()-1,
                std::ostream_iterator<int>(oss, " "));
 
                // Now add the last element with no delimiter
                oss << mystring.back();
                const char* stringtodump=oss.str().c_str();
                fprintf(l_dumpfile, "%s", stringtodump);
            }
 
         break;
     }
        case CFG_ARRAY_DOUBLE:
        {
            CfgArray_Double *l_p = dynamic_cast<CfgArray_Double *>((CfgVals[i].get()));
            std::ostringstream oss;
            auto mystring= l_p->value();
            if (!mystring.empty())
            {
                // Convert all but the last element to avoid a trailing " "
                std::copy(mystring.begin(), mystring.end()-1,
                          std::ostream_iterator<double>(oss, " "));
 
                // Now add the last element with no delimiter
                oss << mystring.back();
                const char* stringtodump=oss.str().c_str();
                fprintf(l_dumpfile, "%s", stringtodump);
            }
 
            break;
        }
    default:
      {
    char l_errno[20];
    sprintf( l_errno, "%d", (CfgVals[ i ].get())->gettype() );
    g_msg->Warn( WARN_FILE, "Configurator::DumpSymbols() "
             "Unknown symbol type read:",
             l_errno );
    exit(1);
      }
    }
    fprintf( l_dumpfile, "  # %s\n",
         CfgSecureStrings[ (CfgVals[ i ].get())->getlevel() ].c_str()
         );
  }
 
}

References CFG_ARRAY_DOUBLE, CFG_ARRAY_INT, CFG_BOOL, CFG_FLOAT, CFG_INT, CFG_MAX_LINE_LENGTH, CFG_STRING, CfgI, CfgSecureStrings, CfgTypeStrings, CfgVals, g_msg, CfgInt::value(), CfgFloat::value(), CfgBool::value(), CfgStr::value(), CfgArray_Int::value(), CfgArray_Double::value(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by DumpAllSymbolsAndExit(), and DumpPublicSymbols().

ExtractString()

std::string Configurator::ExtractString ( std::string  a_line ) const

protected

{
  char lineno[ 20 ];
 
  // scan for the first double quote or end of line.
  std::size_t found_first_quote =a_line.find('"');
  std::size_t found_last_quote =a_line.rfind('"');
  if ((found_first_quote == std::string::npos)||(found_first_quote == found_last_quote)){
      sprintf( lineno, "%d", m_lineno );
      g_msg->Warn( WARN_FILE, "Configurator::ExtractString()\n"
                              "  String not enclosed in double quotes at "
                              "config line ", lineno );
      exit(1);
  }
  // we can get over all this by just using regex
  try{
      std::regex regexp_between_quotes(R"("[^"\\]*(\\.[^"\\]*)*")");
 
      std::smatch smatch;
      std::string therest_str{};
      std::string extracted_str;
      if (std::regex_search(a_line, smatch, regexp_between_quotes)) {
          if (smatch.size() > 1) {
              extracted_str= smatch.str(0); // return the first matching string
              int endofmatch = int(smatch.position(0)+smatch.length(0));
              if (a_line.length()>endofmatch){
                  therest_str = a_line.erase(smatch.position(0), endofmatch);
              }
 
          }
          else {
              sprintf(lineno, "%d", m_lineno);
              g_msg->Warn(WARN_FILE, "Configurator::ExtractString()\n"
                                     "  String not enclosed in double quotes at "
                                     "config line ", lineno);
              exit(1);
          }
 
      }
      if ((!therest_str.empty())&&(therest_str.at(0)!='#')){
          sprintf( lineno, "%d", m_lineno );
 
          g_msg->Warn( WARN_FILE, "Configurator::ExtractString() "
                                  "Illegal comment at "
                                  "config line ", lineno );
          exit(1);
      }
      /*
       * We will strip the quotes (first and last symbol and return it)
       * */
      return extracted_str.substr(1, extracted_str.size() - 2);
  }
  catch (const std::regex_error& e) {
      sprintf(lineno, "%d", m_lineno);
      std::cout << "regex_error caught: " << e.what() << '\n';
      g_msg->Warn(WARN_FILE, "Configurator::ExtractString()\n"
                             "  Regex error ", lineno);
  }
 
  return ""; // Compiler happiness
 
 
}

References g_msg, m_lineno, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine(), and StoreFromConfig().

ParseArrayDouble()

std::vector< double > Configurator::ParseArrayDouble

(

const std::string &

a_stringtoparse

)

                                                                                 {
 
    std::stringstream iss( a_stringtoparse );
 
    double number;
    std::vector<double> myNumbers;
    while ( iss >> number )
        myNumbers.push_back( number );
    return myNumbers;
}

Referenced by StoreFromConfig().

ParseArrayInt()

std::vector< int > Configurator::ParseArrayInt

(

const std::string &

a_stringtoparse

)

                                                                           {
 
    std::stringstream iss( a_stringtoparse );
 
    int number;
    std::vector<int> myNumbers;
    while ( iss >> number )
        myNumbers.push_back( number );
    return myNumbers;
}

Referenced by StoreFromConfig().

ParseCfgLine()

bool Configurator::ParseCfgLine ( std::string  a_line )

protected

{
  std::string l_id  ;
  std::string l_type;
  std::string l_sep ;
  std::string l_val ;
  std::string l_comm;
  char lineno[ 20 ];
  if (a_line.empty()){return false;}// Empty string
  if (a_line.at(0) == '#') { return false; }// Comment line: starts from #
  if ((a_line.at(0) == '/') && (a_line.at(1) == '*'))
  {
      return true;
  }// Comment block: starts from /*
 
  //if (a_line.find_first_not_of(" \t\n\v\f\r") != std::string::npos){return;}// Empty line
  if ( std::all_of(a_line.begin(),a_line.end(),isspace)){return false;}// Empty line
  if (a_line.back() == '\r'){a_line.pop_back();} //If there is /r in the end (reading Win file in Unix)
  // consisting only of white spaces or tabs.
 
 
  //int l_conv = sscanf( a_line, "%[A-Z_] (%[a-z]) %s", l_id, sizeof(l_id),l_type,sizeof(l_type), l_sep,sizeof(l_sep) );
  std::regex regexp_parsing(R"(^([a-zA-Z_]\w*)\s*(\(.*\))\s*=\s*(.*?)\s*([\#].+\w*?)*$)");
  // This may look complicated for the person who never saw regex but we basically extract 4 groups:
  // (1) alphanumeric variable name
  // (2) in brackets (type)
  // =
  // (3) value can be values or numbers or whatever, (since we allow strings)
  // (4: optional) "#comment" (always after #)
 
  std::smatch smatch;
  std::string name_str;
  std::string type_str;
  std::string value_str;
  std::string comment_str;
  sprintf( lineno, "%d", m_lineno );
  if (std::regex_search(a_line, smatch, regexp_parsing)) {
 
      if (smatch.size() > 2) { // comment is optional so there are 3 or 4 groups: zeros element is all matches
          name_str= smatch.str(1);
          type_str = smatch.str(2);
          type_str = type_str.substr(1, type_str.size() - 2); // will remove brackets from around type
          value_str = smatch.str(3);
          comment_str = smatch.str(4);
 
      }
      else{
          sprintf( lineno, "%d", m_lineno );
          g_msg->Warn( WARN_FILE, "Configurator::ParseCfgLine() "
                                  " Unsuccessful parsing: Syntax error at",
                       lineno );
      }
  }
//int l_conv = sscanf( a_line, "%[A-Z_] (%[a-z]) %s", l_id, l_type, l_sep );
 
 
 
 
 
  if ( CfgI.find( name_str ) == CfgI.end() ) {
    // Key doesn't exists among the preloaded global configuration
    // variables. Previously we ignored this quietly. Now we will store it nonetheless
    // in the datastructures
#ifndef _cfgWarningOff
 
    g_msg->WarnAddInfo( WARN_UNDEF, "Configurator::ParseCfgLine() "
                            " Warning: not statically initialised key ("+name_str+") was found in CFG: line ",
                   lineno );
#endif
    this->StoreFromConfig(name_str, type_str, value_str);
 
    return false;
  }
 
  if ( type_str.compare("string")== 0 ) {
    // We are not yet ready to do the assignment.
    // If we really have a string enclosed in non-escaped
    // double quotes at the end of the line, then we need to
    // extract it first from our input.
    SetCfgStr( name_str, ExtractString( value_str+comment_str )); // we send just the 3rd and 4th groups,
                                                    // but this also will do
    return false;
  }
 
  // Not a string, so extract data value and possible comment.
//  l_conv = sscanf( a_line, "%*[A-Z_] (%*[a-z]) %*s %s %s",
//         l_val, l_comm );
//
//  if ( l_conv == 2 && l_comm[0] != '#' ) {
//    // Illegal comment at end of line.
//    sprintf( lineno, "%d", m_lineno );
//    g_msg->Warn( WARN_FILE, "Configurator::ParseCfgLine() "
//       "Syntax error at end of config line ",
//       lineno );
//    exit(1);
//}
    if ( type_str.compare("double")== 0 ){
        SetCfgFloat( name_str, value_str );
        return false;
    }
    if ( type_str.compare("float")== 0 ){
            SetCfgFloat( name_str, value_str );
            return false;
    }
    if ( type_str.compare("bool")== 0 ){
        SetCfgBool( name_str, value_str );
        return false;
    }
    if ( type_str.compare("int")== 0 ){
        SetCfgInt( name_str, value_str );
        return false;
    }
 
    if ( type_str.compare("array int")== 0 ){
        SetCfgArrayInt( name_str, value_str );
        return false;
    }
    if ( type_str.compare("array double")== 0 ){
        SetCfgArrayDouble( name_str, value_str );
        return false;
    }
 
    if ( type_str.compare("array double csv")== 0 ){
        SetCfgArrayDoubleCsv( name_str, value_str );
        return false;
    }
 
    if ( type_str.compare("array int csv")== 0 ){
        SetCfgArrayIntCsv( name_str, value_str );
        return false;
    }
    if ( type_str.compare("function")== 0 ){
        SetCfgFunction( name_str, value_str );
        return false;
    }
  sprintf( lineno, "%d", m_lineno );
  g_msg->Warn( WARN_FILE, "Configurator::ParseCfgLine() "
           "Unknown type specifier at config line ",
           lineno );
  exit(1);
}

References CfgI, ExtractString(), g_msg, m_lineno, SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgInt(), SetCfgStr(), StoreFromConfig(), MapErrorMsg::Warn(), WARN_FILE, WARN_UNDEF, and MapErrorMsg::WarnAddInfo().

Referenced by ReadSymbols().

ParseCommentLine()

bool Configurator::ParseCommentLine ( std::string  a_line )

protected

Reads each line and parses it.

Parameters

a_line

is the line read

Returns

true if the line starts with a long block comment '/*'

Reads each line and checks if it is the end of the comment

Parameters

a_line

is the line read

Returns

true if the line ends with a long block comment end characters ' *''/'

{
    if (a_line.find("*/") != std::string::npos) {
        return true;
    } // NB even if this string is in the middle of a line the rest is ignored, best to use a line only for this
    return false;
}

Referenced by ReadSymbols().

ReadSymbols()

bool Configurator::ReadSymbols

(

const char *

a_cfgfile

)

                                                      {
    std::ifstream cf_file;
    //char cfgline[ CFG_MAX_LINE_LENGTH ]; //maybe we'll change it to std::string later
    std::string cfgline{};
    cf_file.open(a_cfgfile,std::fstream::in);
    if ( !cf_file.is_open() ) {
        g_msg->Warn( WARN_FILE, "Configurator::ReadSymbols() Unable to open file for reading: ", a_cfgfile );
        exit(1);
    }
    while ( !cf_file.eof()) {
    //  for (unsigned i=0; i< CFG_MAX_LINE_LENGTH; i++) cfgline[i]=' '; // Done to get rid of the rubbish that otherwise messes up the parse
        std::getline(cf_file,cfgline);
        if (ParseCfgLine( cfgline ))
        {
            do
            {
                m_lineno++;
                std::getline(cf_file, cfgline);
            } while (!ParseCommentLine(cfgline));
        }
        m_lineno++;
    }
    cf_file.close();
    return true;
}

References g_msg, m_lineno, ParseCfgLine(), ParseCommentLine(), MapErrorMsg::Warn(), and WARN_FILE.

Register() [1/2]

bool Configurator::Register	(	CfgBase *	a_cfgval,
		const std::string &	a_key
	)

{
  const std::string& l_key = a_key;
  char lineno[ 20 ];
 
  if ( CfgI.find( l_key ) != CfgI.end() ) {
    // Couldn't register, already exists.
    // will check if it was defined in cfg file
    // if so envoke checking the value method
    // and after correction return true
 
    if (CfgVals[CfgI.find(l_key)->second]->get_definedinconfig()) {
        sprintf(lineno, "%d", m_lineno);
        /*
        g_msg->Warn( WARN_FILE, "Configurator::Register()\n"
        +a_key+": Registering non-static variable which value was first defined in "
                                "config file. Line: ", "NA");
                                */
        a_cfgval->set_definedinconfig(true);
        return CheckBounds(CfgVals[CfgI.find(l_key)->second], a_cfgval);
 
 
    }else{
        // otherwise
        return false;
    }
 
 
  }
 
  unsigned int i   = (int) CfgVals.size();
  CfgI[ l_key ]    = i;
  CfgVals.resize( i+1 );
  // we will define an empty destructor for statically initiated shared pointer
 
  CfgVals[ i ]    = std::shared_ptr<CfgBase>{std::shared_ptr<CfgBase*>{},a_cfgval};
 
 
 
  return true;
}

References CfgI, CfgVals, CheckBounds(), m_lineno, and CfgBase::set_definedinconfig().

Referenced by StoreFromConfig().

Register() [2/2]

bool Configurator::Register	(	std::shared_ptr< CfgBase >	a_cfgval,
		const std::string &	a_key
	)

An overloaded version of Register for dynamically allocated configs

{
    const std::string& l_key = a_key;
 
    if ( CfgI.find( l_key ) != CfgI.end() ) {
        // Couldn't register, already exists.
        return false;
    }
 
    unsigned int i   = (int) CfgVals.size();
    CfgI[ l_key ]    = i;
    CfgVals.resize( i+1 );
    // we will define an empty destructor for statically initiated shared pointer
 
    CfgVals[i ]    = a_cfgval;
 
 
 
    return true;
}

References CfgI, and CfgVals.

SetCfgArrayDouble()

void Configurator::SetCfgArrayDouble	(	std::string	a_key,
		std::string	a_val
	)

{
    //int l_val;
    char lineno[20];
    std::string l_key = a_key;
 
    std::istringstream iss( a_val );
 
    double number;
    std::vector<double> array_double;
    while ( iss >> number )
        array_double.push_back( number );
    // for now we will leave the gatekeeper
    // Check access security.
    unsigned int i         = CfgI[ l_key ];
    if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
                           "Attempting to set public config variable in line",
                           a_key,
                           (CfgVals[ i ].get())->getlevel()
    )) {
        return;
    }
 
    if ( (CfgVals[ i ].get())->gettype() != CFG_ARRAY_DOUBLE ) {
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
                                "Non-double-array identifier specified at config line",
                     lineno );
        ShowIdType( i );
        exit(1);
    }
    if (array_double.size()==dynamic_cast<CfgArray_Double*>((CfgVals[ i ].get()))->get_array_size()) {
        dynamic_cast<CfgArray_Double *>((CfgVals[i].get()))->set(array_double);
    }
    else{
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgArrayDouble() "
                                "Wrong array length at config line",
                     lineno );
    }
}

References CFG_ARRAY_DOUBLE, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgArrayDoubleCsv()

void Configurator::SetCfgArrayDoubleCsv	(	std::string	a_key,
		std::string	a_val
	)

{
    //int l_val;
    char lineno[20];
    std::string l_key = a_key;
 
    std::istringstream iss( a_val );
 
    int number;
    std::vector<int> array_int;
    while ( iss >> number )
        array_int.push_back( number );
    // for now we will leave the gatekeeper
    // Check access security.
    unsigned int i         = CfgI[ l_key ];
    if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
                           "Attempting to set public config variable in line",
                           a_key,
                           (CfgVals[ i ].get())->getlevel()
    )) {
        return;
    }
 
    if ( (CfgVals[ i ].get())->gettype() != CFG_ARRAY_DOUBLE ) {
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
                                "Non-array-double identifier specified at config line",
                     lineno );
        ShowIdType( i );
        exit(1);
    }
 
    dynamic_cast<CfgArray_Int*>((CfgVals[ i ].get()))->set( array_int );
}

References CFG_ARRAY_DOUBLE, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgArrayInt()

void Configurator::SetCfgArrayInt	(	std::string	a_key,
		std::string	a_val
	)

{
    //int l_val;
    char lineno[20];
    std::string l_key = a_key;
 
    std::istringstream iss( a_val );
 
    int number;
    std::vector<int> array_int;
    while ( iss >> number )
        array_int.push_back( number );
    // for now we will leave the gatekeeper
    // Check access security.
    unsigned int i         = CfgI[ l_key ];
    if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
                           "Attempting to set public config variable in line",
                           a_key,
                           (CfgVals[ i ].get())->getlevel()
    )) {
        return;
    }
 
    if ( (CfgVals[ i ].get())->gettype() != CFG_ARRAY_INT ) {
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgArrayInt() "
                                "Non-array-integer identifier specified at config line",
                     lineno );
        ShowIdType( i );
        exit(1);
    }
    if (array_int.size()==dynamic_cast<CfgArray_Int*>((CfgVals[ i ].get()))->get_array_size()){
        dynamic_cast<CfgArray_Int*>((CfgVals[ i ].get()))->set( array_int );
    }else{
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgArrayInt() "
                                "Wrong array length at config line",
                     lineno );
    }
 
}

References CFG_ARRAY_INT, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgArrayIntCsv()

void Configurator::SetCfgArrayIntCsv	(	std::string	a_key,
		std::string	a_val
	)

{
    //int l_val;
    char lineno[20];
    std::string l_key = a_key;
 
    std::istringstream iss( a_val );
 
    int number;
    std::vector<int> array_int;
    while ( iss >> number )
        array_int.push_back( number );
    // for now we will leave the gatekeeper
    // Check access security.
    unsigned int i         = CfgI[ l_key ];
    if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
                           "Attempting to set public config variable in line",
                           a_key,
                           (CfgVals[ i ].get())->getlevel()
    )) {
        return;
    }
 
    if ( (CfgVals[ i ].get())->gettype() != CFG_ARRAY_INT ) {
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
                                "Non-array-int identifier specified at config line",
                     lineno );
        ShowIdType( i );
        exit(1);
    }
 
    dynamic_cast<CfgArray_Int*>((CfgVals[ i ].get()))->set( array_int );
}

References CFG_ARRAY_INT, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgBool()

void Configurator::SetCfgBool	(	std::string	a_key,
		std::string	a_val
	)

{
  char lineno[20];
  std::string l_key = a_key;
  bool   l_val = false;
 
  if (  a_val.compare( "false" ) == 0 ) {
    ; // l_val defaults to false.
  } else if (  a_val.compare( "true" ) == 0 ) {
    l_val = true;
  } else {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgBool() "
         "Not a boolean data value at config line",
         lineno );
    exit(1);
  }
 
  // Check access security.
  unsigned int i         = CfgI[ l_key ];
  if ( SetCfgGatekeeper( "Configurator::SetCfgBool() "
             "Attempting to set public config variable in line",
             a_key,
             (CfgVals[ i ].get())->getlevel()
             )) {
    return;
  }
 
  if ( (CfgVals[ i ].get())->gettype() != CFG_BOOL ) {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgBool() "
         "Non-boolean identifier specified at config line",
         lineno );
    ShowIdType( i );
    exit(1);
  }
 
  dynamic_cast<CfgBool*>((CfgVals[ i ].get()))->set( l_val );
}

References CFG_BOOL, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgFloat()

void Configurator::SetCfgFloat	(	std::string	a_key,
		std::string	a_val
	)

{
  double l_val;
  double f;
  char lineno[20];
  std::string l_key = a_key;
 
  if ( sscanf( a_val.c_str(), "%lf", &f) != 1 ) {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgFloat() "
         "Not a floating point data value at config line",
         lineno );
    exit(1);
  }
  //FloatToDouble(l_val,f);
  l_val = f;
 
  // Check access security.
  unsigned int i         = CfgI[ l_key ];
  if ( SetCfgGatekeeper( "Configurator::SetCfgFloat() "
             "Attempting to set public config variable in line",
             a_key,
             (CfgVals[ i ].get())->getlevel()
             )) {
    return;
  }
 
  if ( (CfgVals[ i ].get())->gettype() != CFG_FLOAT ) {
sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgFloat() "
         "Non-floating point identifier specified at config line",
         lineno );
    ShowIdType( i );
    exit(1);
  }
 
  dynamic_cast<CfgFloat*>((CfgVals[ i ].get()))->set( l_val );
}

References CFG_FLOAT, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgFunction()

void Configurator::SetCfgFunction	(	std::string	a_key,
		std::string	a_val
	)

{
    //int l_val;
    char lineno[20];
    std::string l_key = a_key;
 
    std::istringstream iss( a_val );
 
    int number;
    std::vector<double> array_double;
    while ( iss >> number )
        array_double.push_back( number );
    // for now we will leave the gatekeeper
    // Check access security.
    unsigned int i         = CfgI[ l_key ];
    if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
                           "Attempting to set public config variable in line",
                           a_key,
                           (CfgVals[ i ].get())->getlevel()
    )) {
        return;
    }
 
    if ( (CfgVals[ i ].get())->gettype() != CFG_INT ) {
        sprintf( lineno, "%d", m_lineno );
        g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
                                "Non-integer identifier specified at config line",
                     lineno );
        ShowIdType( i );
        exit(1);
    }
 
    dynamic_cast<CfgArray_Double*>((CfgVals[ i ].get()))->set( array_double );
}

References CFG_INT, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgGatekeeper()

bool Configurator::SetCfgGatekeeper ( const std::string  a_method, const std::string  a_key, CfgSecureLevel  a_level  )

protected

{
  if ( a_level == CFG_PRIVATE ) {
    // Attempting to set private config variable. Ignore quietly.
    return true;
  }
 
  if ( a_level == CFG_PUBLIC &&
       l_cfg_public_warn_on_set.value()) {
    // Attempting to set public config variable. Warn and
    // possibly exit if this is configured.
    char lineno[20];
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, a_method, lineno );
 
    if ( l_cfg_public_exit_on_set.value()) {
      exit(1);
    }
    return true;
  }
  return false;
}

References CFG_PRIVATE, CFG_PUBLIC, g_msg, l_cfg_public_exit_on_set, l_cfg_public_warn_on_set, m_lineno, CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgInt(), and SetCfgStr().

SetCfgInt()

void Configurator::SetCfgInt	(	std::string	a_key,
		std::string	a_val
	)

{
  int l_val;
  char lineno[20];
  std::string l_key = a_key;
 
  if ( sscanf( a_val.c_str(), "%d", &l_val ) != 1 ) {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
         "Not an integer data value at config line",
         lineno );
    exit(1);
  }
  // for now we will leave the gatekeeper
  // Check access security.
  unsigned int i         = CfgI[ l_key ];
  if ( SetCfgGatekeeper( "Configurator::SetCfgInt() "
             "Attempting to set public config variable in line",
             a_key,
                         (CfgVals[ i ].get())->getlevel()
             )) {
    return;
  }
 
  if ( (CfgVals[ i ].get())->gettype() != CFG_INT ) {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgInt() "
         "Non-integer identifier specified at config line",
         lineno );
    ShowIdType( i );
    exit(1);
  }
 
  dynamic_cast<CfgInt*>(CfgVals[ i ].get())->set( l_val );
}

References CFG_INT, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

SetCfgStr()

void Configurator::SetCfgStr	(	std::string	a_key,
		std::string	a_val
	)

{
  char lineno[20];
  std::string l_key = a_key;
 
  // Check access security.
  unsigned int i         = CfgI[ l_key ];
  if ( SetCfgGatekeeper( "Configurator::SetCfgStr() "
             "Attempting to set public config variable in line",
             a_key,
             (CfgVals[ i ].get())->getlevel()
             )) {
    return;
  }
 
  if ( (CfgVals[ i ].get())->gettype() != CFG_STRING ) {
    sprintf( lineno, "%d", m_lineno );
    g_msg->Warn( WARN_FILE, "Configurator::SetCfgStr() "
         "Non-string identifier specified at config line",
         lineno );
    ShowIdType( i );
    exit(1);
  }
 
  dynamic_cast<CfgStr*>((CfgVals[ i ].get()))->set( a_val );
}

References CFG_STRING, CfgI, CfgVals, g_msg, m_lineno, SetCfgGatekeeper(), ShowIdType(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

ShowIdType()

void Configurator::ShowIdType ( unsigned int  a_i )

protected

{
  g_msg->WarnAddInfo( WARN_FILE,
              "Type for identifier ",
                      (CfgVals[ a_i ].get())->getkey().c_str() );
  g_msg->WarnAddInfo( WARN_FILE, " is (",
              CfgTypeStrings[ (CfgVals[ a_i ].get())->gettype() ] );
  g_msg->WarnAddInfo( WARN_FILE, ")\n", "" );
}

References CfgTypeStrings, CfgVals, g_msg, WARN_FILE, and MapErrorMsg::WarnAddInfo().

Referenced by SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgInt(), and SetCfgStr().

StoreFromConfig()

void Configurator::StoreFromConfig	(	const std::string &	name,
		std::string	type,
		std::string	value
	)

                                                                                         {
    char lineno[20];
    if (type.compare("int") == 0){
        int l_val;
        if ( sscanf( value.c_str(), "%d", &l_val ) != 1 ) {
            sprintf(lineno, "%d", m_lineno);
            g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig() "
                                   "Not an integer data value at config line",
                        lineno);
            exit(1);
        }
 
        //will create first an object of CfgInt (will allocate memory for it)
        auto new_object (std::make_shared<CfgInt>( CfgInt ( name,CFG_CUSTOM,l_val, true)));
        // register it in "database" : for dynamically allocated data this function "moves" the ownership of the object
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
 
    } else if (type.compare("bool") == 0){
        bool l_val{false};
        if (  value.compare( "false" ) == 0 ) {
            ; // l_val defaults to false.
        } else if (  value.compare( "true" ) == 0 ) {
            l_val = true;
        } else {
            sprintf( lineno, "%d", m_lineno );
            g_msg->Warn( WARN_FILE, "Configurator::SetCfgBool() "
                                    "Not a boolean data value at config line",
                         lineno );
            exit(1);
        }
 
        //will create first an object of CfgInt
        auto new_object (std::make_shared<CfgBool>( CfgBool ( name,CFG_CUSTOM,l_val, true)));
 
        // register it in "database"
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
 
    } else if ((type.compare("double") == 0)||(type.compare("float") == 0)){
        double l_val;
        if ( sscanf( value.c_str(), "%lf", &l_val ) != 1 ) {
            sprintf(lineno, "%d", m_lineno);
            g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig() "
                                   "Not an double data value at config line",
                        lineno);
            exit(1);
        }
 
        //will create first an object of CfgFloat
        auto new_object (std::make_shared<CfgFloat>( CfgFloat ( name,CFG_CUSTOM,l_val, true)));
 
        // "register" it in "database"
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
 
    }
    else if (type.compare("string") == 0) {
 
 
        //will create first an object of CfgInt
        auto new_object (std::make_shared<CfgStr>(CfgStr (name, CFG_CUSTOM, ExtractString(value), true)));
        // register it in "database"
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
    }
    else if (type.compare("array int") == 0) {
        try {
            std::regex int_regex("(\s*(-*[0-9]+\s+)+\s*)");
 
 
            std::smatch smatch;
            std::string therest_str{};
            std::string extracted_str;
            if (std::regex_search(value, smatch, int_regex)) {
                if (smatch.size() < 1) {
                    sprintf(lineno, "%d", m_lineno);
                    g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig() "
                                           + name + " Unsuccessful parsing: Syntax error at",
                                lineno);
                }
            }
        }
        catch (const std::regex_error& e) {
            sprintf(lineno, "%d", m_lineno);
            std::cout << "regex_error caught: " << e.what() << '\n';
            g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig()\n"
                                   "  Regex error ", lineno);
        }
        std::vector<int> array_vec=ParseArrayInt(value);
        int a_numvals = int(array_vec.size());
 
        //will create first an object of CfgInt
        auto new_object (std::make_shared<CfgArray_Int>(CfgArray_Int (name, CFG_CUSTOM, a_numvals, array_vec, true)));
        // register it in "database"
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
    }
    else if (type.compare("array double") == 0) {
        try {
            std::regex int_regex("(\s*(-*[0-9.]+\s+)+\s*)");
 
 
            std::smatch smatch;
            std::string therest_str{};
            std::string extracted_str;
            if (std::regex_search(value, smatch, int_regex)) {
                if (smatch.size() < 1) {
                    sprintf(lineno, "%d", m_lineno);
                    g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig() "
                                           + name + " Unsuccessful parsing: Syntax error at",
                                lineno);
                }
            }
        }
        catch (const std::regex_error& e) {
            sprintf(lineno, "%d", m_lineno);
            std::cout << "regex_error caught: " << e.what() << '\n';
            g_msg->Warn(WARN_FILE, "Configurator::StoreFromConfig()\n"
                                   "  Regex error ", lineno);
        }
        std::vector<double> array_vec=ParseArrayDouble(value);
        int a_numvals = int(array_vec.size());
 
        //will create first an object of CfgInt
        auto new_object (std::make_shared<CfgArray_Double>(CfgArray_Double (name, CFG_CUSTOM, a_numvals, array_vec, true)));
        // register it in "database"
        this->Register(std::move(std::static_pointer_cast<CfgBase>(new_object)) , name );
 
    }
}

References CFG_CUSTOM, ExtractString(), g_msg, m_lineno, ParseArrayDouble(), ParseArrayInt(), Register(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ParseCfgLine().

Member Data Documentation

CfgI

std::map<std::string, unsigned int> Configurator::CfgI

protected

Referenced by DumpSymbols(), ParseCfgLine(), Register(), SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgInt(), and SetCfgStr().

CfgVals

std::vector<std::shared_ptr<CfgBase> > Configurator::CfgVals

protected

Referenced by DumpSymbols(), Register(), SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgInt(), SetCfgStr(), and ShowIdType().

m_lineno

unsigned int Configurator::m_lineno

protected

Referenced by Configurator(), ExtractString(), ParseCfgLine(), ReadSymbols(), Register(), SetCfgArrayDouble(), SetCfgArrayDoubleCsv(), SetCfgArrayInt(), SetCfgArrayIntCsv(), SetCfgBool(), SetCfgFloat(), SetCfgFunction(), SetCfgGatekeeper(), SetCfgInt(), SetCfgStr(), and StoreFromConfig().

---

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

• /builds/ALMaSS/ALMaSS_MIDox/Landscape/Configurator.h
• /builds/ALMaSS/ALMaSS_MIDox/Landscape/Configurator.cpp