---

IotrConfiguration.hh

#ifndef IOTRCONFIGURATION
#define IOTRCONFIGURATION

#include <map>
#include <string>
#include <iostream>
#include "IotrRefCount.hh"
#include "IotrHandle.hh"
#include <regex.h>
#include <errno.h>

enum { configFound = 0, configUnused, configNotFound, expectedString,
       expectedReal, expectedInteger, expectedConfiguration };

template<typename T>
struct IotrOption {
  const char * key;
  T value;
  const char * comment;
};

typedef IotrOption<double> FloatOption;
typedef IotrOption<int>    IntOption;
typedef IotrOption<const char*>  CharOption;

class IotrConfiguration;
class IotrConfigOption : public IotrRefCount {
  friend class IotrConfiguration;
protected:
  int mMarked;
  int mIsScalar;
public:
  IotrConfigOption( int isScalar ) :
    mMarked(configUnused), mIsScalar( isScalar ) {}
  int isScalar() const { return mIsScalar; }
  int marked() const { return mMarked; }
  virtual void write( std::ostream &, const char * indent ) const = 0;
};

typedef Handle<IotrConfigOption> IotrConfigOptionHandle;

class IotrConfiguration : public IotrRefCount {
protected:
  std::map<std::string,IotrConfigOptionHandle> mConfig;
  template<typename T>
  int findOptionT(T & opt,  const char * key,
                int mark, int & err, int expectedT ) const;
public:
  int findOption( IotrConfiguration &, const char * key,
                  int mark, int & err ) const;
  int findOption( std::string & opt, const char * key,
                  int mark, int & err ) const
  {
    return this->findOptionT( opt, key, mark, err, expectedString );
  }
  int findOption( double & opt, const char * key,
                  int mark, int & err ) const
  {
    return this->findOptionT( opt, key, mark, err, expectedReal );
  }
  int findOption( int & opt, const char * key,
                  int mark, int & err ) const
  {
    return this->findOptionT( opt, key, mark, err, expectedInteger );
  }

  void insert( const char * key, const char * value,
               const char * comment = 0  );
  void insert( const char * key, int value, const char * comment = 0  );
  void insert( const char * key, double value, const char * comment = 0  );
  void insert( const char * key, IotrConfiguration * config,
               const char * comment = 0  );
  template<typename T>
  void insertList( IotrOption<T> opts[] );

  void shallowCopy( const IotrConfiguration & config )
  { mConfig = config.mConfig; }
  void reportErrors() const;
  int findErrors( IotrConfiguration & unused,
                  IotrConfiguration & bad ) const;

  int insertShorthand( const char opt[] );

  void overrideWith( const IotrConfiguration & config );

  void write( std::ostream & s, const char * indent,
              const char * comment = 0 ) const;
  int empty() const { return mConfig.empty(); }

  virtual void inspect() const { write( std::cout, "" ); }
};


class IotrConfigParser {
protected:
  regex_t  beginConfigDoc, beginDoc, endDoc, comment, scalarTag, complexTag;

  int read_config_line( std::istream & in, std::string & s, int & line );
  int readDocument( std::istream & in, IotrConfiguration & config,
                    std::string & s,
                    int & line, int indent_level );
public:
  IotrConfigParser();
  ~IotrConfigParser();
  int readStream( std::istream & optStream, IotrConfiguration & config );
};


typedef Handle<IotrConfiguration> IotrConfigurationHandle;


#endif

---