InputParameters.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "common/toolbox/InputParameters.hpp"
 
//#include <algorithm>
 
#include "common/core/CepsFlags.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/toolbox/CepsString.hpp"
#include "common/containers/CepsVector.hpp"
 
 
InputParameters::InputParameters() :
  m_keyVals    ({}),
  m_warnDefault(true)
{}
 
InputParameters::InputParameters(const CepsString& s, CepsBool warnDefault) :
  FileReader   (s),
  m_keyVals    ({}),
  m_warnDefault(warnDefault)
{
  read();
}
 
InputParameters::~InputParameters()
{
}
 
void
InputParameters::read()
{
  m_keyVals.clear();
 
  CEPS_SAYS("Reading parameters from file " << m_fileName);
  CEPS_ABORT_IF(not open(),
    "InputParameters: unable to open file " << m_fileName
  );
 
  CepsVector<CepsString> lines;
  CepsString             l, key, value, KEY;
  CepsBool               readNewEntry(true);
  while (getline(m_file, l))
    lines.push_back(l);
 
  for (CepsUInt iLine=0U; iLine<lines.size(); iLine++)
  {
    CepsString line(lines.at(iLine));
    if (readNewEntry)
    {
      if (line.find(':')!=line.npos and not line.starts_with('#'))
      {
        std::stringstream ss(line);
        getline(ss,key, ':');
        getline(ss,value);
        // Remove spaces from keys and make it upper for storage
        KEY   = ceps::toKey(key);
        value = ceps::trim (value);
 
        CEPS_WARNS_IF(KEY.empty(),
          "In parameters file, key is empty at line " << iLine
        );
        CEPS_WARNS_IF(value.empty(),
          "Empty value at line " << iLine << " of parameter file"
        );
 
        // Several lines spanning entries
        if (value.ends_with('\\'))
        {
          readNewEntry = false;
          value.pop_back();
          value = ceps::trim(value) + ' ';
        }
 
        // Append if multiple lines have the same key
        if (hasKey(keyType(KEY)))
          m_keyVals.at(KEY) += CepsString(",") + value;
        else
          m_keyVals.insert(std::make_pair(keyType(KEY),value));
      }
    }
    else
    {
      value = ceps::trim(line);
      if (value.ends_with('\\'))
      {
        readNewEntry = false;
        value.pop_back();
        value = ceps::trim(value) + " ";
      }
      else
      {
        readNewEntry = true;
      }
      if (value.empty())
        m_keyVals.at(keyType(KEY)).pop_back(); // remove added space
      else
        m_keyVals.at(keyType(KEY)) += value;
    }
  }
 
}
 
// -----------------------------------------------------------------=
// Get values from parameters
 
CepsReal
InputParameters::getReal(const keyType& key) const
{
  keyType KEY = ceps::toKey(key);
  errIfNoKey(key,"real value");
  return ceps::toReal(m_keyVals.at(KEY));
}
 
CepsReal
InputParameters::getReal(const keyType& key, const CepsReal& defVal) const
{
  keyType KEY = ceps::toKey(key);
  if (not m_keyVals.contains(KEY))
  {
    warnNoKey(key,std::to_string(defVal),"real value");
    return defVal;
  }
  return ceps::toReal(m_keyVals.at(KEY));
}
 
CepsMathVertex
InputParameters::getMathVertex(const keyType& key) const
{
  keyType KEY = ceps::toKey(key);
  errIfNoKey(key,"vertex value");
  return ceps::toMathVertex(ceps::split(m_keyVals.at(KEY)));
}
 
CepsMathVertex
InputParameters::getMathVertex(const keyType& key, const CepsMathVertex& defVal) const
{
  keyType KEY = ceps::toKey(key);
  if (not m_keyVals.contains(KEY))
  {
    std::stringstream def;
    def << CepsString("(") << defVal(0) << "," << defVal(1) << "," << defVal(2) << ")";
    warnNoKey(key,def.str(),"vertex value");
    return defVal;
  }
  return ceps::toMathVertex(ceps::split(m_keyVals.at(KEY)));
}
 
CepsInt
InputParameters::getInt(const keyType& key) const
{
  keyType KEY = ceps::toKey(key);
  errIfNoKey(key,"integer value");
  return ceps::toInt(m_keyVals.at(KEY));
}
 
CepsInt
InputParameters::getInt(const keyType& key, const CepsInt& defVal) const
{
  keyType KEY = ceps::toKey(key);
  if (not m_keyVals.contains(KEY))
  {
    warnNoKey(key,std::to_string(defVal),"integer value");
    return defVal;
  }
  return ceps::toInt(m_keyVals.at(KEY));
}
 
CepsString
InputParameters::getString(const keyType& key) const
{
  keyType KEY = ceps::toKey(key);
  errIfNoKey(key,"string value");
  return m_keyVals.at(KEY);
}
 
CepsString
InputParameters::getString(const keyType& key, const CepsString& defVal) const
{
  keyType KEY = ceps::toKey(key);
  if (not m_keyVals.contains(KEY))
  {
    warnNoKey(key,defVal,"string value");
    return defVal;
  }
  return m_keyVals.at(KEY);
}
 
CepsString
InputParameters::operator()(const keyType& key) const
{
  return this->getString(key);
}
 
CepsString
InputParameters::operator()(const keyType& key, const keyType& defVal) const
{
  return this->getString(key, defVal);
}
 
CepsBool
InputParameters::hasKey(const keyType& key) const
{
  return m_keyVals.contains(ceps::toKey(key));
}
 
CepsBool
InputParameters::isActiveOption(const keyType& key) const
{
  keyType val = ceps::toKey(getString(key,"NO"));
  CepsVector<CepsString> oks {"YES","TRUE","1","ON","OK"};
  return ceps::contains(oks,val);
}
 
CepsBool
InputParameters::isInactiveOption(const keyType& key) const
{
  keyType val = ceps::toKey(getString(key,"YES"));
  CepsVector<CepsString> oks {"NO","FALSE","0","OFF"};
  return ceps::contains(oks,val);
}
 
void
InputParameters::errIfNoKey(const keyType& key, const CepsString& type) const
{
  keyType KEY = ceps::toKey(key);
  CEPS_ABORT_IF(not m_keyVals.contains(KEY),
    "No " << type <<" with key \"" << key << "\" found in parameters file"
  );
}
 
void
InputParameters::warnNoKey(const keyType& key, const CepsString& defValue, const CepsString& type) const
{
  CEPS_WARNS(
    "No " << type << " with key \"" << key << "\" found in parameters file. Will use default: " << defValue
  );
}
 
void
InputParameters::set
(const keyType& key, const CepsString& value)
{
  m_keyVals[ceps::toKey(key)] = ceps::trim(value);
}
 
void
InputParameters::set
(const keyType& key, const CepsReal& value)
{
  this->set(key,ceps::toString(value));
}
 
void
InputParameters::set
(const keyType& key, const CepsInt& value)
{
  this->set(key,ceps::toString(value));
}
 
void
InputParameters::erase(const keyType& key)
{
  m_keyVals.erase(ceps::toKey(key));
}