Param.h

Go to the documentation of this file.

// $Id: Param.h,v 1.3 2009/04/22 16:26:24 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 <typename 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.  (For those still learning
    // C++: the following item defines fDataType as a pointer to a
    // function that accepts no arguments and returns a type_info
    // reference; similarly, all the rest of these class members are
    // function pointers.)
    const std::type_info& (*fDataType)(void);
    const std::type_info& (*fVectorType)(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 const std::type_info& gsVectorType(void) 
    {
      return typeid(typename T::value_type);
    }
  
  //......................................................................
  
  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 ),
    fVectorType  ( 0 ),
    fDataDelete  ( 0 ),
    fDataCopyCons( 0 ),
    fDataCopy    ( 0 ),
    fDataPrint   ( 0 )
    {
      this->Set(d);
    }
  
  //......................................................................

  template <typename T>
  void Param::Get( T& item ) const
  {
    // Basic check: The types match exactly.  In that case, just
    // make a copy and return it.
    const std::type_info& typeInfo = typeid( T );
    if ( typeInfo == this->fDataType() ) 
      {
        // Copy the parameter into the return object.
        item = (*(T*)fData);
        return;
      }
    else
      {
        // Perhaps the user has asked for a simple type.  This is
        // fine, as long this parameter is vector of that type and
        // only has a single value.
        if ( typeInfo == this->fVectorType() )
          {
            // The parameter is a vector of the type that the user requests.
            std::vector<T>& param = (*(std::vector<T>*)fData);
            // Does this vector have exactly one element in it?
            if ( param.size() == 1 )
              {
                // Yes, so return that item.
                item = param.front();
                return;
              }
            else
              {
                std::ostringstream os;
                os << "Parameter " << this->GetName() << " has multiple values of type "
                   << typeInfo.name();
                throw cfg::Exception(Exception::kTypeMismatch,
                                     os.str().c_str(),
                                     __FILE__,
                                     __LINE__);
              }
          }
      }
    // If we get here, we don't know how to handle the
    // difference between the type the user has requested
    // and the type of this parameter.  Throw an exception.
    std::ostringstream os;
    os << "Attempt to get data of type " << typeInfo.name()
       << " from parameter " << this->GetName() << " which is of type "
       << this->fDataType().name() << " (a vector of " 
       << this->fVectorType().name() << ")";
    throw cfg::Exception(Exception::kTypeMismatch,
                         os.str().c_str(),
                         __FILE__,
                         __LINE__);
  }
  
  //......................................................................
  
  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>;
      fVectorType   = gsVectorType<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

---