Parameter.hh

Go to the documentation of this file.

//Copyright 2013 Ben Loer
//This file is part of the ConfigHandler library
//It is released under the terms of the GNU General Public License v3

#ifndef PARAMETER_h
#define PARAMETER_h
#include "VParameterNode.hh"
#include "ParameterIOimpl.hh"
#include "Message.hh"
#include "phrase.hh"

#include <stdexcept>
#include <string>
#include <cstdlib>
#include <typeinfo>
#include <ctime>
#include <cstdio>



class ParameterList;

template<class T> class Parameter : public VParameterNode{
public:
  Parameter(T& t, const std::string& key="", const std::string& helptext = "") :
    VParameterNode(key, helptext), _val(t) {_node_type = PARAMETER;}
  Parameter(const Parameter& right) : 
    VParameterNode(right._default_key, right._helptext), _val(right._val) {}
  virtual ~Parameter() {};
  Parameter& operator=(const Parameter& right){ _val=right._val; return *this;}
  const T& GetValue() const { return _val; }
  const T* GetPointer() const { return &_val; }
  virtual int PrintHelp(const std::string& myname="") const;
    
  virtual Parameter<T>* Clone(const void* from, void* to) const;
  
  typedef T param_type;
protected:
  virtual std::istream& ReadFrom( std::istream& in , bool single=false);
  virtual std::ostream& WriteTo( std::ostream& out , bool showhelp=false, 
                                 int indent=0) const;
  
  //implementation of read/write is done with impls so we can overload
  /*std::istream& read_impl(std::istream& in, T& t){ return in>>t; }
  std::ostream& write_impl(std::ostream& out, T& t, 
                           bool showhelp=false, int indent=0){ return out<<t; }
  */
  //specific impl overload
  
private:
  T& _val; 
};

template<class T> 
inline std::istream& Parameter<T>::ReadFrom(std::istream& in, bool)
{
  if( !ParameterIOimpl::read(in, _val) && !in.eof()){
    Message e(EXCEPTION);
    e<<"Error trying to read parameter with default key "<<_default_key<<"!\n";
    throw std::invalid_argument(e.str());
  }
  return in;
}

template<class T> 
inline std::ostream& Parameter<T>::WriteTo(std::ostream& out, bool showhelp, int indent) const
{
  return ParameterIOimpl::write(out, _val, showhelp, indent);
}

template<class T>
inline int Parameter<T>::PrintHelp(const std::string& myname) const
{
  VParameterNode::PrintHelp(myname);
  std::cout<<"Parameter type: "<<typeid(_val).name()<<"\n"
           <<"Current Value:  ";
  ParameterIOimpl::write(std::cout, _val, true);
  std::cout<<std::endl;
  std::string dummy;
  std::cout<<"\nHit <enter> to continue.";
  std::getline(std::cin, dummy);
  std::getline(std::cin, dummy);
  
  return 0;
}

template<class T> inline 
Parameter<T>* Parameter<T>::Clone(const void* from, void* to) const
{
  unsigned diff = (const char*)(GetPointer()) - (const char*)from;
  return new Parameter<T>((T&)(*( (char*)to+diff )), _default_key, _helptext); 
}


#endif