---

config.H

Go to the documentation of this file.

#ifndef _config_H_
#define _config_H_
#include <std/strings.H>
#include <std/config.H>
#include "std/strstream.H" // localize strstream.h weirdness

/* This module defines a global configuration manager that reads in (a) config 
   file(s) and makes it available to user code, either through method calls or 
   by registering variables to take the data. This should also handle
   automatically getting different configuration files for different
   environments of one sort or another, but it doesn't yet. In general you
   should use this by using the CONFIGmap class which establishes and
   disestablishes mappings between config lines and variables (which currently 
   doesn't do anything more than initial setup but may in the future). */

class CONFIGmapbase {
   public:
      virtual ~CONFIGmapbase() {}
      virtual void remap(Cstr_ptr &newval) = 0;
};

class DllImpExp CONFIG {
 private:
          HASH<str_ptr> _entries;
   static CONFIG  *_config;

 public:
          void     read_file(istream &cfgfile);

                   CONFIG();
          void     add_config_line(Cstr_ptr &line);
          str_ptr *register_map  (Cstr_ptr &name, CONFIGmapbase *);
          void     unregister_map(Cstr_ptr &,     CONFIGmapbase *) {}
   static CONFIG  *mainconfig()       { if (!_config) _config = new CONFIG;
                                        return _config; }
   static void     init(int &argc, char **argv);
  
   // will call read_file for any argument that contains the string
   // "glueconfig" in it.
   static void     init_with_filenames(int &argc, char **argv);
};

template <class T>
static inline
bool
decode_it(Cstr_ptr &str, T &v) {
   istrstream istr(**str);
   istr >> v;
   return !istr ? false : true;
}

static inline bool decode_it(Cstr_ptr &str, str_ptr &v) {v = str; return true;}
extern DllImpExp void CONFIGmissing(Cstr_ptr &);

#ifdef GLUEBASE_VER
extern DllImpExp void CONFIGnotread(Cstr_ptr &);
#endif

template <class V>
class CONFIGmap : public CONFIGmapbase {
   Cstr_ptr  n_;
   V        &v_;
 public:
   CONFIGmap(Cstr_ptr &name, V &variable, bool warn=true):n_(name),v_(variable)
   {
     str_ptr *ret = CONFIG::mainconfig()->register_map(n_, this);
     if (ret) {
       remap(*ret);  
     } else if (warn)
       CONFIGmissing(n_);
   }
  
   virtual ~CONFIGmap() { CONFIG::mainconfig()->unregister_map(n_, this); };
   virtual void remap(Cstr_ptr &myval) {
      if (!decode_it(myval, v_)) {
         cerr << "Garbled config file entry \"" << myval << "\" for  tag \""
              << n_ << "\".\n";
      }
   }
};

template <class V>
class CONFIGget : public CONFIGmapbase {
  V        v_;
  Cstr_ptr n_;
public:
  CONFIGget(Cstr_ptr &n, const V &dflt, bool warn=true)
    : v_(dflt), n_(n)
  { 
    str_ptr *ret = CONFIG::mainconfig()->register_map(n, this);
    if (ret) {
      remap(*ret);
    } else if (warn)
      CONFIGmissing(n);
  }
  
  virtual     ~CONFIGget()  { CONFIG::mainconfig()->unregister_map(n_, this); };
  
  V            operator *()           { return v_; }
  virtual void remap(Cstr_ptr &myval) {
    if (!decode_it(myval, v_)) {
      cerr << "Garbled config file entry \"" << myval
       << "\" for  tag \"" << n_ << "\".\n";
    }
  }
};

//
// bcz: here's the deal.  We want to be able to just load in a CONFIG 
//      variable by inferring the variable type from the default 
//      parameter passed to CONFIGval.  However, in the case of strings,
//      the default may be passed in as a quoted string.  The problem
//      with this is that the type will not be promoted to str_ptr,
//      and we'll try overwriting the static string which is bad.
//      So, we have to define exceptions to the template that will
//      catch the quoted_string stuff and do the promotion.  Once again,
//      a problem arises because different compilers have different
//      type descriptions for a quoted string.
//
// Compilers that think a quoted string is a const char *:
//    SUNWspro 5.0 and later
//    g++ 2.96 and later
//
#if (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500) || \
    (defined(__GNUC__) && (__GNUC__ > 2 || \
                         (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)))
#define QUOTED_STRING const char *
#else
#define QUOTED_STRING char *
#endif
inline str_ptr CONFIGval(QUOTED_STRING n, QUOTED_STRING dflt="", bool warn=true)
   { return *CONFIGget<str_ptr>(n,str_ptr(dflt),warn); }
#if defined(WIN32) || (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500)
   // VC++ can't seem to promote both variables
inline str_ptr CONFIGval(str_ptr &n, QUOTED_STRING dflt="", bool warn=true) 
   { return *CONFIGget<str_ptr>(n,str_ptr(dflt),warn); }
#endif
inline str_ptr CONFIGval(Cstr_ptr &n, QUOTED_STRING dflt="", bool warn=true) 
   { return *CONFIGget<str_ptr>(n,str_ptr(dflt),warn); }

// XXX AIX xlC does not allow default parameters in template functions
#ifdef _AIX
template <class S, class V>
V CONFIGval(S n, const V &dflt) 
   { return *CONFIGget<V>(n,dflt,true); }
template <class S, class V>
V CONFIGval(S n, const V &dflt, bool warn) 
   { return *CONFIGget<V>(n,dflt,warn); }
#else
template <class S, class V>
V CONFIGval(S n, const V &dflt, bool warn=true) 
   { return *CONFIGget<V>(n,dflt,warn); }
#endif

inline str_ptr 
CONFIGrecurse(Cstr_ptr &n, Cstr_ptr &dflt, bool warn=true)
{
   str_ptr maps_to;
   if ((maps_to = CONFIGval(n, dflt, warn)) != dflt)
      return CONFIGrecurse(maps_to, maps_to, false);
   else
      return maps_to;
}


/* This function and macro are for use only for global variables, not for
   function-local or member variables. */
template <class V>
inline V &
CONFIGmapper(Cstr_ptr &name, V &var, const V &dflt)
{
   var = dflt;
   new CONFIGmap<V>(name, var);
   return var;
}

#define CONFIG_DECLARE(VAR,DEFAULT) VAR = CONFIGmapper(str_ptr(#VAR), VAR, DEFAULT)

#endif

---