Configuration.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/units/Configuration.h
 
#ifndef __Configuration_h
#define __Configuration_h
 
#include "Reference.h"
#include "tostring.h"
#include "debug.h"
#include "Error.h"
 
#include <vector>
#include <iostream>
#include <sstream>
 
 
class Configuration
{
public:
 
  virtual ~Configuration () {}
 
  Configuration (const char* filename = 0);
 
  void load (const std::string& filename);
 
  class Entry;
 
  template<typename T> class Parameter;
 
  template<typename T> T get (const std::string& key, T default_value) const;
 
  template<typename T> T get (const std::string& key) const;
 
  Entry* find (const std::string& key) const;
 
  const std::vector<std::string>& get_filenames () const { return filenames; }
 
  unsigned get_find_count () const { return find_count; }
 
protected:
 
  virtual void load () {}
 
  std::vector<std::string> filenames;
  std::vector<Entry> entries;
 
private:
 
  mutable unsigned find_count;
};
 
class Configuration::Entry
{
public:
  Entry (std::string& k, std::string& v) { key=k; value=v; }
  std::string key;
  std::string value;
};
 
 
template<class T>
class Configuration::Parameter : public Reference::Able
{
public:
 
  Parameter ()
  {
    loader = 0;
  }
 
  Parameter (const T& val)
  {
    value = val;
    loader = 0;
  }
 
  Parameter (const std::string& _key, Configuration* config, T default_value)
  {
    key = _key;
    loader = new DirectLoader (default_value);
    loader->parameter = this;
    loader->configuration = config;
  }
 
  Parameter (const std::string& _key, Configuration* config)
  {
    key = _key;
    loader = new DirectLoader;
    loader->parameter = this;
    loader->configuration = config;
  }
 
  template<typename Parser>
  Parameter (const std::string& _key, Configuration* config,
             Parser* parser, const std::string& default_value)
  {
    DEBUG("Configuration::Parameter<T> ctor parser=" << parser);
    key = _key;
    loader = new ParseLoader<Parser> (parser, default_value);
    loader->parameter = this;
    loader->configuration = config;
  }
 
  ~Parameter ()
  {
    if (loader)
      delete loader;
  }
 
  operator T& ()
  {
    if (loader)
      loader->load();
 
    return value;
  }
 
  T get_value () const
  {
    if (loader)
      loader->load();
 
    return value;
  }
 
  void set_value (const T& val)
  {
    value = val;
    if (loader)
      loader->destroy();
  }
 
  T& operator = (const T& t) { set_value(t); return value; }
 
  bool operator == (const T& t) const { return get_value() == t; }
 
  class Loader;
 
  class DirectLoader;
 
  template<class P> class ParseLoader;
 
  std::string get_key () const { return key; }
  void set_key (const std::string& _key) { key = _key;}
 
  void set_loader (Loader* _load)
  {
    DEBUG("Configuration::Parameter::set_loader this=" << this \
          << " key=" << key << " loader=" << _load);
 
    if (loader)
      loader->destroy();
    loader = _load;
    loader->parameter = this;
  }
 
protected:
  std::string key;
  T value;
  Loader* loader;
};
 
template<typename T>
class Configuration::Parameter<T>::Loader
{
public:
 
  virtual ~Loader() {}
 
  virtual void load () = 0;
 
  void destroy ()
  {
    parameter->loader = 0;
    delete this;
  }
 
  Configuration* configuration;
  Parameter* parameter;
};
 
template<typename T>
class Configuration::Parameter<T>::DirectLoader : public Loader
{
public:
 
  DirectLoader () { default_value_set = false; }
 
  DirectLoader (const T& _default) 
  { default_value = _default; default_value_set = true; }
 
  virtual void load ()
  {
    Parameter<T>* param = this->parameter;
    Configuration* config = this->configuration;
 
    if (default_value_set)
    {
      param->value = config->get (param->key, default_value);
  
      DEBUG("Configuration::Parameter<T>::Loader::load key=" << param->key \
            << " default=" << default_value << " value=" << param->value);
    }
    else if (config->find (param->key))
    {
      param->value = config->get<T> (param->key);
 
      DEBUG("Configuration::Parameter<T>::Loader::load key=" << param->key \
            << " value=" << param->value);
    }
 
    this->destroy();
  }
 
protected:
  T default_value;
  bool default_value_set;
};
 
template<typename T>
template<typename P>
class Configuration::Parameter<T>::ParseLoader : public Loader
{
public:
 
  ParseLoader (P* _parser, const std::string& _default)
  {
    DEBUG("Configuration::Parameter<T>::ParseLoader ctor parser=" << _parser);
    parser = _parser;
    default_value = _default;
  }
 
  virtual void load ()
  {
    std::string value 
      = this->configuration->get (this->parameter->key, default_value);
 
    DEBUG("Configuration::Parameter<T>::ParseLoader::load" \
    " parser=" << (void*) this->parser.ptr() << \
          " key=" << this->parameter->key << \
          " default=" << this->default_value << \
          " value=" << value);
 
    parser->parse( value );
 
    DEBUG("Configuration::Parameter<T>::ParseLoader::load parse method called");
 
    /* the parser must call either set_value or the assignment operator,
       which will result in the destruction of this loader */
  }
 
protected:
  Reference::To<P> parser;
  std::string default_value;
};
 
template<typename T> 
T Configuration::get (const std::string& key, T default_value) const
{
  Entry* entry = find (key);
  if (entry)
  {
    DEBUG("Configuration::get found entry->value=" << entry->value); 
    return fromstring<T> (entry->value);
  }
 
  DEBUG("Configuration::get default " << key << " = " << default_value);
 
  return default_value;
}
 
template<typename T>
T Configuration::get (const std::string& key) const
{
  Entry* entry = find (key);
  if (entry)
  {
    DEBUG("Configuration::get found entry->value=" << entry->value);
    return fromstring<T> (entry->value);
  }
  else
    throw Error (InvalidParam, "Configuration::get", "entry not found");
}
 
#endif