parameterfile.h

Go to the documentation of this file.

/***************************************************************************
                          parameterfile.h  -  description
                             -------------------
    begin                : Wed May 8 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef PARAMETERFILE_H
#define PARAMETERFILE_H


#include <string>
#include <iostream>
#include <sstream>
#include <fstream>

#include <vector>

#include <complex>
#include <cmath>
#include <typeinfo>

#include <simthetic/misc.h>
#include <simthetic/exceptions.h>
#include <simthetic/checkedvector.h>

namespace simth
{


template<class T>
class checkedVector;



bool isComment(const std::string& token);
void nextLine(std::istream& inputStream);
bool seekToToken(const std::string& token, std::istream& parameterStream,bool ignoreComments=true);
bool isToken(const std::string& token, std::istream& parameterStream,bool ignoreComments=true);
std::string getStream(const std::string& token, std::istream& is);
std::string getStream(const std::string& region, const std::string& token, std::istream& is);

std::string getString(const std::string& token, std::istream& parameterStream);

std::string getPathname(const std::string& token, std::istream& parameterStream);
simth::checkedVector<std::string> getPathnameSeq(const std::string& token, std::istream& istr);
bool        getBool(const std::string& token, std::istream& parameterStream);
int         getInt(const std::string& token, std::istream& parameterStream);
unsigned    getOctal(const std::string& istring);
int         getOctal(const std::string& token, std::istream& parameterStream);
double      getDouble(const std::string& token, std::istream& parameterStream);
template<class T>
checkedVector<T> getDecSeq(const std::string& token, std::istream& is);
checkedVector<int> getDecSeq(const std::string& token, std::istream& is);
std::vector<int> getOctalSeq(const std::string& helpString);
checkedVector<int> getOctalSeq(const std::string& token, std::istream& is);
template<class T>
checkedVector<std::complex<T> > getComplSeq(const std::string& token, std::istream& is);

std::string getString(const std::string& token, std::istream& parameterStream, std::string defaultStr);
std::string getLine(const std::string& token, std::istream& parameterStream, std::string defaultStr);

std::string getPathname(const std::string& token, std::istream& parameterStream, std::string defaultStr);
bool        getBool(const std::string& token, std::istream& parameterStream, bool defaultStatus);
int         getInt(const std::string& token, std::istream& parameterStream, int defaultVal);
int         getOctal(const std::string& token, std::istream& parameterStream, int defaultVal);
double      getDouble(const std::string& token, std::istream& parameterStream, double defaultVal);


bool seekToToken(const std::string& region, const std::string& token,
                 std::istream& parameterStream, const std::string endQualifier = "[end]");
bool isToken(const std::string& region, const std::string& token, std::istream& parameterStream);

std::string getString(const std::string& region, const std::string& token, std::istream& parameterStream);
//std::string getLine(const std::string& region, const std::string& token, std::istream& parameterStream);

std::string getPathname(const std::string& region, const std::string& token, std::istream& parameterStream);
bool        getBool(const std::string& region, const std::string& token, std::istream& parameterStream);
int         getInt(const std::string& region, const std::string& token, std::istream& parameterStream);
int         getOctal(const std::string& region, const std::string& token, std::istream& parameterStream);
double      getDouble(const std::string& region, const std::string& token, std::istream& parameterStream);
Complex     getComplex(const std::string& region, const std::string& token, std::istream& is);
checkedVector<int> getDecSeq(const std::string& region, const std::string& token, std::istream& is);
checkedVector<int> getOctalSeq(const std::string& region, const std::string& token, std::istream& is);

template<class T> std::vector<T> 
getSeq(const std::string&);

template<class T>
checkedVector<T> getSeq(const std::string& region, const std::string& token, std::istream& is);

template<class T>
checkedVector<T> getSeq(const std::string& region, const std::string& token, std::istream& is,checkedVector<T> defaultSeq);

template<class T>
checkedVector<std::complex<T> > getComplSeq(const std::string& region, const std::string& token, std::istream& is);

std::string getString(const std::string& region, const std::string& token, std::istream& parameterStream, std::string defaultStr);
std::string getLine(const std::string& region, const std::string& token, std::istream& parameterStream, std::string defaultStr);

std::string getPathname(const std::string& region, const std::string& token, std::istream& parameterStream, std::string defaultStr);
bool        getBool(const std::string& region, const std::string& token, std::istream& parameterStream, bool defaultStatus);
int         getInt(const std::string& region, const std::string& token, std::istream& parameterStream, int defaultVal);
int         getOctal(const std::string& region, const std::string& token, std::istream& parameterStream, int defaultVal);
double      getDouble(const std::string& region, const std::string& token, std::istream& parameterStream, double defaultVal);


size_t getSequenceLength(const std::string& token, std::istream& parameterStream);

size_t getSequenceLength(const std::string& token, std::istream& parameterStream, int defaultVal);

size_t getSequenceLength(const std::string& region, const std::string& token, std::istream& parameterStream);

size_t getSequenceLength(const std::string& region, const std::string& token, std::istream& parameterStream, int defaultVal);


template<class T>
inline std::ostream& printParameter(const std::string& name, T value,std::ostream &os )
{
  //save old format settings:
  std::ios::fmtflags oldSettings = os.flags();
  os.width(0);
  os<<"# ";
  os.width(15);
  os<<name.c_str();
  os.width(0);
  os<<": "<<value;
  os.setf(oldSettings);
  return os;  
}


bool isFilemaskMatched(const char *mask, const char *s);


} // namespace


#ifndef DOXYGEN_IGNORE 

template<class T>
simth::checkedVector<T> simth::getDecSeq(const std::string& token, std::istream& is)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = is.flags();
  std::string helpString;
  std::string testString;
  T helpValue;
  checkedVector<T> helpPol(0);
  if(seekToToken(token, is)) { //ok, read the following word:
    std::streampos currPos = is.tellg(); //in ANSI C++ pos_type statt streampos!?
    while(is >> testString) {
      if(isComment(testString)) {
        break;
      }
      is.seekg(currPos);
      //if(test != '\n'){
      //is.unget();
      if(is >> helpValue) {
        helpPol.push_back(helpValue);
      }
      else {
        throw std::runtime_error(testString+" is no valid value to"
                                 " specify a "+typedid(helpValue).name()+" sequence for '"+token+"'");
      }
      currPos = is.tellg();
    }
    if(helpPol.size() > 0) {
      is.clear();
      is.setf(oldSettings);
      return helpPol;
    }
    else {
      is.clear();
      is.setf(oldSettings);
      throw std::runtime_error(token+" has no valid value");
    }
  }
  else {
    throw simth::token_not_found(token);
  }
}


template<class T> std::vector<T> 
simth::getSeq(const std::string& helpString)
{
  std::istringstream is(helpString);
  //save old format settings:
  std::string testString;
  T helpValue;
  std::vector<T> helpPol(0);

  std::streampos currPos = is.tellg(); //in ANSI C++ pos_type statt streampos!?
  while(is >> testString) {
    if(isComment(testString)) {
      break;
    }
    is.seekg(currPos);
    //if(test != '\n'){
    //is.unget();
    if(is >> helpValue) {
      helpPol.push_back(helpValue);
    }
    else {
      throw std::runtime_error(testString+" is no valid value to"
                   " specify a "+typeid(helpValue).name()+" sequence");
    }
    currPos = is.tellg();
  }
  return helpPol;
}

template<class T>
inline simth::checkedVector<T> simth::getSeq(const std::string& region, const std::string& token, std::istream& is)
{
  // FIXME: use getSeq(string) here instead of implementing this twice.
  //save old format settings:
  std::ios::fmtflags oldSettings = is.flags();
  std::string helpString;
  std::string testString;
  T helpValue;
  checkedVector<T> helpPol(0);
  if(seekToToken(region, token, is)) { //ok, read the following word:
    std::streampos currPos = is.tellg(); //in ANSI C++ pos_type statt streampos!?
    while(is >> testString) {
      if(isComment(testString)) {
        break;
      }
      is.seekg(currPos);
      //if(test != '\n'){
      //is.unget();
      if(is >> helpValue) {
        helpPol.push_back(helpValue);
      }
      else {
        throw std::runtime_error(testString+" is no valid value to"
                                 " specify a "+typeid(helpValue).name()+" sequence for '"+token+"'");
      }
      currPos = is.tellg();
    }
    if(helpPol.size() > 0) {
      is.clear();
      is.setf(oldSettings);
      return helpPol;
    }
    else {
      is.clear();
      is.setf(oldSettings);
      throw std::runtime_error(token+" has no valid value");
    }
  }
  else {
    throw simth::token_not_found(token);
  }
}




template<class T>
inline simth::checkedVector<T> simth::getSeq(const std::string& region, const std::string& token, std::istream& is,simth::checkedVector<T> defaultSeq)
{
  try {
    return simth::getSeq<T>(region, token, is);
  } catch (simth::token_not_found) {
    return defaultSeq;
  }
}


namespace simth {

template<class T>
inline checkedVector<std::complex<T> > getComplSeq(const std::string& token, std::istream& is)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = is.flags();
  std::string helpString;
  std::string testString;
  std::complex<T> helpValue;
  checkedVector<std::complex<T> > helpPol(0);
  if(seekToToken(token, is)) { //ok, read the following word:
    std::streampos currPos = is.tellg(); //in ANSI C++ pos_type statt streampos!?
    while(is >> testString) {
      if(isComment(testString)) {
        break;
      }
      is.seekg(currPos);
      //if(test != '\n'){
      //is.unget();
      if(std::operator>>(is,helpValue)) {  //can be replaced from SuSe 8.1 by std::operator>>(...)
        helpPol.push_back(helpValue);
      }
      else {
        throw std::runtime_error(testString+" is no valid value to"
                                 " specify a complex sequence");
      }
      currPos = is.tellg();
    }
    is.clear();
    is.setf(oldSettings);
    return helpPol;
  }
  else {
    throw simth::token_not_found(token);
  }
}


template<class T>
inline checkedVector<std::complex<T> > getComplSeq(const std::string& region, const std::string& token, std::istream& is)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = is.flags();
  std::string helpString;
  std::string testString;
  std::complex<T> helpValue;
  checkedVector<std::complex<T> > helpPol(0);
  if(seekToToken(region, token, is)) { //ok, read the following word:
    std::streampos currPos = is.tellg(); //in ANSI C++ pos_type statt streampos!?
    while(is >> testString) {
      if(isComment(testString)) {
        break;
      }
      is.seekg(currPos);
      //if(test != '\n'){
      //is.unget();
      if(operator>>(is,helpValue)) {
        helpPol.push_back(helpValue);
      }
      else {
        throw std::runtime_error(testString+" is no valid value to"
                                 " specify a complex sequence");
      }
      currPos = is.tellg();
    }
    is.clear();
    is.setf(oldSettings);
    return helpPol;
  }
  else {
    throw simth::token_not_found(token);
  }
}
} // namespace

#endif // DOXYGEN_IGNORE


namespace simth {
class PropertyList;
void readProperties(const std::string& region,
                    std::istream& parameterStream,
            PropertyList& properties);


} // namespace

#endif // PARAMETERFILE_H

---