ParameterList.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 PARAMETERLIST_h
#define PARAMETERLIST_h

#include "VParameterNode.hh"
#include "Parameter.hh"
#include "ConfigFunctor.hh"
#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <iostream>
#include "Message.hh"
#include <boost/type_traits.hpp>
#include <boost/shared_ptr.hpp>


class ParameterList : public VParameterNode{
public:
  ParameterList(const std::string& key="", const std::string& helptext="") : 
    VParameterNode(key, helptext) { _node_type = PARAMETER_LIST; }
  virtual ~ParameterList();
  virtual ParameterList* Clone(const void* from, void* to) const
  {return (ParameterList*)((char*)to + ((const char*)this-(const char*)from));}
protected:
  ParameterList(const ParameterList& right);
  ParameterList& operator=(const ParameterList& right);
  void CopyPlistRelative(const ParameterList& right);
public:
  virtual void InitializeParameterList() { std::cerr<<"InitializeParameterList\n";}

  virtual std::istream& ReadFrom( std::istream& in, bool single=false);
  virtual std::ostream& WriteTo( std::ostream& out , bool showhelp=false, 
                                 int indent=0) const;
  virtual int PrintHelp(const std::string& myname="") const;
  template<class T> int RegisterParameter(const std::string& key, T& par,
                                          const std::string& helptext="");
  template<class R, class W> 
  int RegisterFunction(const std::string& key,
                       const R& read, 
                       const W& write,
                       const std::string& helptext="");
  template<class R> int RegisterReadFunction(const std::string& key, 
                                             const R& read,
                                             const std::string& helptext="");
  template<class W> int RegisterWriteFunction(const std::string& key, 
                                              const W& write,
                                              const std::string& helptext="");
  VParameterNode* const GetParameter(const std::string& key);
protected:
  typedef std::map<std::string, VParameterNode*> ParMap;
  ParMap _parameters;   
  
  std::vector<boost::shared_ptr<VParameterNode> > _deleter; 
  
  template<class T> 
  int RegisterParameterImp(const std::string& key, T& par, 
                           const std::string& helptext,
                           const boost::false_type&);
  template<class T>
  int RegisterParameterImp(const std::string& key, T& par, 
                           const std::string& helptext, 
                           const boost::true_type&);
};

template<class T>
inline int ParameterList::RegisterParameter(const std::string& key,
                                            T& par,
                                            const std::string& helptext)
{
  if( _parameters.find(key) != _parameters.end() ){
    Message(ERROR)<<"Parameter with key \""<<key
             <<"\" already exists in this list!"<<std::endl;
    return -1;
  }
  
  return RegisterParameterImp(key,par,helptext,
                              boost::is_base_of<VParameterNode,T>());
}

//template specialization
template<class T>
inline int ParameterList::RegisterParameterImp(const std::string& key, 
                                               T& par,
                                               const std::string& helptext,
                                               const boost::true_type&)
{
  _parameters.insert(std::make_pair(key,&par));
  return 0;
}

template<class T> 
inline int ParameterList::RegisterParameterImp(const std::string& key,
                                               T& par,
                                               const std::string& helptext,
                                               const boost::false_type&)
{
  boost::shared_ptr<VParameterNode> ptr(new Parameter<T>(par, key, helptext) );
  _deleter.push_back(ptr);
  _parameters.insert(std::make_pair(key,ptr.get()));
  return 0;
}

template<class R, class W>
inline int ParameterList::RegisterFunction(const std::string& key,
                                           const R& reader, const W& writer,
                                           const std::string& helptext)
{
  if( _parameters.find(key) != _parameters.end() ){
    Message(ERROR)<<"Parameter with key \""<<key
             <<"\" already exists in this list!"<<std::endl;
    return -1;
  }
  
  boost::shared_ptr<VParameterNode> 
    ptr(new ConfigFunctor<R,W>(reader, writer, key, helptext));
  _deleter.push_back(ptr);
  _parameters.insert(std::make_pair(key, ptr.get()));
  return 0;
}

template<class R>
inline int ParameterList::RegisterReadFunction(const std::string& key,
                                               const R& reader,
                                               const std::string& helptext)
{
  int r = RegisterFunction(key, reader, ConfigFunctorDummyWrite(), helptext); 
  if(r==0)
    _parameters[key]->haswrite = false;
  return r;
}

template<class W>
inline int ParameterList::RegisterWriteFunction(const std::string& key,
                                                const W& writer,
                                                const std::string& helptext)
{
  int r = RegisterFunction(key, ConfigFunctorDummyRead(), writer, helptext);
  if(r == 0)
    _parameters[key]->hasread = false;
  return r;
}

#endif