textfile_parser.hpp

/* textfile_parser.hpp */
/* $Id: textfile_parser.hpp,v 1.4 2008/09/29 14:54:02 sad Exp $ */ 
#ifndef COMMON_TEXTFILEPARSER_HPP
#define COMMON_TEXTFILEPARSER_HPP


#include <string>
#include <map>
#include <ios>
#include <stdexcept>
#include <limits>
#include <cerrno>
#include <string.h>
#include <stdlib.h>



class param_exception : public std::exception {
public:
  param_exception(const char* err_message) : message(err_message) {};
  virtual const char* what() const throw() { return message.c_str();  };
  virtual ~param_exception() throw() {};
private:
  std::string message;
};







class Parameter;

class TextFileParser { 
public:

  TextFileParser() : m_delimeters(new char[3]) { strcpy(m_delimeters, " \t"); };


  void set_delimeters(const char* delims);

  
  virtual void register_parameter(Parameter* p);


  virtual void parse(const char* fname) throw(param_exception, std::ios_base::failure, std::length_error);

  const char* delims() const { return m_delimeters; };

  
  virtual ~TextFileParser() { delete[] m_delimeters; };

private:
  char* m_delimeters;
  std::map<std::string, Parameter*> parameters;  // map of string names of parameters and parameters themselves
};









//-------------------------------------------------------------------------
class Parameter {
  friend class TextFileParser;
public:

  virtual void set_value(const char*) throw(param_exception) = 0;

  const std::string& get_name() const  { return param_name; };

  bool is_inited() const { return is_init; };

  bool is_unique() const { return is_uniq; };


  virtual ~Parameter() {};
protected:
  
  Parameter(const char* name  , 
        bool unique=true  );
  
  bool is_init;    // This flag shows that paramater is inted already (It sets to true automatically by TextFileParser.).
  bool is_uniq;    // This flag shows , that parameter must be unique;

  const TextFileParser* parser;   // Pointer to parser for backward connection.

private:
  std::string param_name;
};





class Int_Parameter : public Parameter
{
public:

  Int_Parameter(const char* name) : Parameter(name) {};
  

  void set_value(const char* strint) throw(param_exception) 
  {
    char* end;
    long lint = strtol(strint, &end, 10);    
    value = static_cast<int>(lint);
    if (end && strlen(end) != 0) 
      if (*end == ' ')  
    throw param_exception("Unexpected token after int value");
      else
    throw param_exception("Can't parse int value for this parameter.");    
    else {
      if (std::numeric_limits<int>::max() < lint) errno = ERANGE;
      if (errno == ERANGE) 
    throw param_exception("Specified value is out of range for this parameter. (int type overflow).");    
    }
  };
    
  
  int get_value() const { return value; };
  
protected:
  int value;
};






class UnsignedInt_Parameter : public Int_Parameter
{
public:
  UnsignedInt_Parameter(const char* str) :
    Int_Parameter(str)
  {}
  
  void set_value(const char* str) throw(param_exception) {
    Int_Parameter::set_value(str);
    if (value <= 0)
      throw param_exception("Value must be more than zero.");
  }  
};






class Double_Parameter : public Parameter
{
public:
  Double_Parameter(const char* name) : Parameter(name) {};

  void set_value(const char* double_val) throw(param_exception);

  double get_value() const {
    return value;
  };

protected:
  double value;
};





class UnsignedDouble_Parameter : public Double_Parameter
{
public:
  UnsignedDouble_Parameter(const char* name) :
    Double_Parameter(name)
  {}

  void set_value(const char* str) throw(param_exception) {
    Double_Parameter::set_value(str);
    if (value <= 0.0)
      throw param_exception("This parameter must be > 0.0");
  }
};







class CharString_Parameter : public Parameter
{
public:
  CharString_Parameter(const char* name) : Parameter(name) {};
  void set_value(const char* name) throw(param_exception);
  const char* get_value() const { return value.c_str(); };
protected:
  std::string value;
};





class CharUndelimString_Parameter : public CharString_Parameter
{
public:
  CharUndelimString_Parameter(const char* name) : CharString_Parameter(name) {};
  void set_value(const char* name) throw(param_exception);
};













#endif // COMMON_TEXTFILEPARSER_HPP