Config.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/Config.h
 
#ifndef __Pulsar_Config_h
#define __Pulsar_Config_h
 
#include "Configuration.h"
#include "TextInterfaceInterpreter.h"
#include "CommandParser.h"
 
namespace Pulsar 
{
  class Config : public Configuration 
  {
  public:

    Config ();

    void set_filename (const std::string&);

    static std::string get_home ();
    
    static std::string get_runtime ();

    static Config* get_configuration ();
 
    class Interface;

    static Interface* get_interface ();


    static void ensure_linkage ();
 
  protected:

    static Config* config;
    
    static Interface* interface;

    void load ();
 
    std::string filename;
    bool databases_loaded;
  };
 

  template<typename T>
  class Option : public Configuration::Parameter<T>
  {
 
  public:

    Option (const std::string& name, const T& default_value,
            const std::string& description = "none",
            const std::string& detailed_description = "none" );

    Option (CommandParser* parser,
            const std::string& name,
            const std::string& default_value,
            const std::string& description = "none",
            const std::string& detailed_description = "none" );

    Option (Configuration::Parameter<T>& parameter,
            const std::string& name, const T& default_value,
            const std::string& description = "none",
            const std::string& detailed_description = "none" );

    Option (Configuration::Parameter<T>& parameter,
            const std::string& name,
            const std::string& description = "none",
            const std::string& detailed_description = "none" );

    Option (Configuration::Parameter<T>& parameter,
            CommandParser* parser,
            const std::string& name,
            const std::string& default_value,
            const std::string& description = "none",
            const std::string& detailed_description = "none" );

    T& operator = (const T& t)
    { Configuration::Parameter<T>::set_value(t); return *this; }
 
    std::string description;
    std::string detailed_description;
  };
 
  template<typename T>
  std::ostream& operator << (std::ostream& ostr, const Option<T>& o)
  { return ostr << o.get_value(); }
 
  template<typename T>
  std::istream& operator >> (std::istream& istr, Option<T>& option)
  { T val; istr >> val; option.set_value (val); return istr; }
 
  class Config::Interface : public TextInterface::Parser
  {
  public:
 
    Interface () { alphabetical = true; }
 
    template<typename T>
    class Element
    {
    public:
      typedef TextInterface::Attribute< Configuration::Parameter<T> > Type;
    };
 
    template<typename T>
    typename Element<T>::Type* add (Option<T>* option)
    {
      TextInterface::Allocator< Configuration::Parameter<T>,T > gen;
      
      typename Element<T>::Type* getset;
 
      getset = gen (option->get_key(),
                    &Configuration::Parameter<T>::get_value,
                    &Configuration::Parameter<T>::set_value);
 
      getset->instance = option;
      getset->set_description (option->description);
      getset->set_detailed_description (option->detailed_description);
 
      add_value( getset );
      return getset;
    }
 
    template<typename T, typename Parser>
    void add (Option<T>* option, Parser* parser)
    {
      add_value( TextInterface::new_Interpreter( option->get_key(),
                                                 option->description,
                                                 option->detailed_description,
                                                 parser,
                                                 &CommandParser::empty,
                                                 &CommandParser::parse ) );
    }
  };
}
 
 
template<typename T>
Pulsar::Option<T>::Option (const std::string& _name,
                           const T& _default,
                           const std::string& _description,
                           const std::string& _detailed_description)
  : Configuration::Parameter<T> (_name, Config::get_configuration(), _default)
{
  DEBUG("Pulsar::Option<T> name=" << _name \
        << " description=" << _description << " default=" << _default);
 
  description = _description;
  detailed_description = _detailed_description;
 
  DEBUG("Pulsar::Option<T> add to interface");
 
  Config::get_interface()->add (this);
 
  DEBUG("Pulsar::Option<T> return");
}
 
template<typename T>
Pulsar::Option<T>::Option (CommandParser* parser,
                           const std::string& _name,
                           const std::string& _default,
                           const std::string& _description,
                           const std::string& _detailed_description )
  : Configuration::Parameter<T> (_name, Config::get_configuration(),
                                 parser, _default)
{
  DEBUG("Pulsar::Option<T> parser around Configuration::parameter");
 
  description = _description;
  detailed_description = _detailed_description;
 
  DEBUG("Pulsar::Option<T> parser add to interface");
 
  Config::get_interface()->add (this, parser);
 
  DEBUG("Pulsar::Option<T> parser return");
}
 
template<typename T>
Pulsar::Option<T>::Option (Configuration::Parameter<T>& parameter,
                           const std::string& _name, const T& _default,
                           const std::string& _description,
                           const std::string& _detailed_description )
  : Configuration::Parameter<T> (_name, Config::get_configuration(), _default)
{
  DEBUG("Pulsar::Option<T> wrap Configuration::parameter");
 
  description = _description;
  detailed_description = _detailed_description;
  parameter.set_key (_name);
 
  parameter.set_loader( this->loader );
  this->loader = 0;
 
  DEBUG("Pulsar::Option<T> wrap add to interface");
 
  Config::get_interface()->add(this)->instance = &parameter;
 
  DEBUG("Pulsar::Option<T> wrap return");
}
 
template<typename T>
Pulsar::Option<T>::Option (Configuration::Parameter<T>& parameter,
                           const std::string& _name,
                           const std::string& _description,
                           const std::string& _detailed_description )
  : Configuration::Parameter<T> (_name, Config::get_configuration())
{
  DEBUG("Pulsar::Option<T> wrap Configuration::parameter");
 
  description = _description;
  detailed_description = _detailed_description;
  parameter.set_key (_name);
 
  parameter.set_loader( this->loader );
  this->loader = 0;
 
  DEBUG("Pulsar::Option<T> wrap add to interface");
 
  Config::get_interface()->add(this)->instance = &parameter;
 
  DEBUG("Pulsar::Option<T> wrap return");
}
 
template<typename T>
Pulsar::Option<T>::Option (Configuration::Parameter<T>& parameter,
                           CommandParser* parser,
                           const std::string& _name,
                           const std::string& _default,
                           const std::string& _description,
                           const std::string& _detailed_description )
  : Configuration::Parameter<T> (_name, Config::get_configuration(),
                                 parser, _default)
{
  DEBUG("Pulsar::Option<T> wrap parser around Configuration::parameter");
 
  description = _description;
  detailed_description = _detailed_description;
  parameter.set_key (_name);
 
  DEBUG("Pulsar::Option<T> wrap parser that=" << &parameter << " loader=" << this->loader);
 
  parameter.set_loader( this->loader );
  this->loader = 0;
 
  DEBUG("Pulsar::Option<T> wrap parser add to interface");
 
  Config::get_interface()->add (this, parser);
 
  DEBUG("Pulsar::Option<T> wrap parser return");
}
 
#endif