Param.h

Go to the documentation of this file.

// $Id: Param.h,v 1.2 2008/09/22 18:28:41 fmwk Exp $
//
// messier@indiana.edu
#ifndef CFG_PARAM_H
#define CFG_PARAM_H
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <typeinfo>
#include <ctime>
#include "Config/Exception.h"

namespace cfg {
  //
  class Param {
  public:
    friend std::ostream& operator<<(std::ostream& os, const Param& p);
    
  public:
    Param();
    Param(const Param& p);
    Param(const char* name, const char* comment);
    template <class T>
      Param(const char* name, const T& d, const char* comment);
    ~Param();
    
  public:
    const char* GetName()               const;
    const char* GetComment()            const;
    const char* XMLTag()                const;
    void        Print(std::ostream& os) const;
    
    template <class T> void Get(T& t) const;
    
  public:
    template <class T> void Set(const T& t);
    Param& operator=(const Param& rhs);
    
    
  private:
    std::string fName;    
    std::string fComment; 
    void*       fData;    
    
  private:
    // The following methods allow one to correctly treat the void*
    // fData as a class of correct type
    const std::type_info& (*fDataType)(void);
    void                  (*fDataDelete)(void*);
    void                  (*fDataCopyCons)(void** dest, const void* src);
    void                  (*fDataCopy)(void* dest, const void* src);
    void                  (*fDataPrint)(std::ostream& os, const void* d);
  };
  
  // Inlined templated functions
  
  template <class T>
    static const std::type_info& gsDataType(void) 
    {
      return typeid(T);
    }
  
  //......................................................................
  
  template <class T>
    static void gsDataDelete(void* p) 
    {
      T* pc = (T*)p; delete pc; 
    }
  
  //......................................................................

  template <class T>
    static void gsDataCopyCons(void** dest, const void* src) 
    {
      T* srcc = (T*)src;
      T* newt = new T(*srcc);
      *dest   = (void*)newt;
    }
  
  //......................................................................

  template <class T>
    static void gsDataCopy(void* dest, const void* src) 
    {
      T* destc = (T*)dest;
      T* srcc  = (T*)src;
      (*destc) = (*srcc);
    }
  
  //......................................................................

  template <class T>
    static void gsDataPrint(std::ostream& os, const void* p)
    {
      T* pc = (T*)p;
      os << (*pc);
    }
  
  //......................................................................
  
  template <class T>
    static std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) 
    {
      int sz   = v.size();
      int szm1 = sz-1;
      if ( (typeid(T) == typeid(std::string)) || 
           (typeid(T) == typeid(const char*)) ) {
        // Add quotes if data is of string type
        for (int i=0; i<sz; ++i) {
          if (i==szm1) os << "\"" << v[i] << "\"";
          else         os << "\"" << v[i] << "\" ";
        }
      }
      else {
        // Non-string data gets streamed normally
        for (int i=0; i<sz; ++i) {
          if (i==szm1) os << v[i];
          else         os << v[i] << " ";
        }
      }
      return os;
    }
  
  //......................................................................

  template <class T>
    Param::Param(const char* name, const T& d, const char* comment) :
    fName        ( name    ),
    fComment     ( comment ),
    fData        ( 0 ),
    fDataType    ( 0 ),
    fDataDelete  ( 0 ),
    fDataCopyCons( 0 ),
    fDataCopy    ( 0 ),
    fDataPrint   ( 0 )
    {
      this->Set(d);
    }
  
  //......................................................................
  
  template <class T>
    void Param::Get(T& t) const
    {
      // Check that types match
      const std::type_info& ti = typeid(T);
      if (ti != this->fDataType()) {
        std::ostringstream os;
        os << "Attempt to get data of type " << ti.name()
           << " from parameter " << this->GetName() << " which is of type "
           << this->fDataType().name();
        throw cfg::Exception(Exception::kTypeMismatch,
                             os.str().c_str(),
                             __FILE__,
                             __LINE__);
      }
      // Normal case: types match so just make a copy to t
      t = (*(T*)fData);
    }
  
  //......................................................................
  
  template <class T>
    void Param::Set(const T& t)
    {
      // Delete the data currently held
      if (fData) {
        this->fDataDelete(fData);
        fData = 0;
      }
      
      // Setup the methods for handling this datum
      fDataType     = gsDataType<T>;
      fDataDelete   = gsDataDelete<T>;
      fDataCopyCons = gsDataCopyCons<T>;
      fDataCopy     = gsDataCopy<T>;
      fDataPrint    = gsDataPrint<T>;
      
      // Create the data from the data passed in
      fDataCopyCons(&fData, &t);
    }
}
#endif // CFGPARAM_H

---