Pars.h

Go to the documentation of this file.

// Copyright András Vukics 2006–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)
// -*- C++ -*-
#ifndef CPPQEDCORE_UTILS_PARS_H_INCLUDED
#define CPPQEDCORE_UTILS_PARS_H_INCLUDED

#include "ParsFwd.h"

#include "BooleanNegatedProxy.h"
#include "Exception.h"

#include <boost/ptr_container/ptr_list.hpp>

#include <string>
#include <sstream>


namespace parameters {

const size_t maxTypeLabelLength=24;



void update(ParameterTable& p,
            int argc, 
            char* argv[], 
            const std::string& prefix="--" 
           );


// 
// Pars Exceptions
//


class Exception : public cpputils::Exception
{
public:
  virtual ~Exception() {}
};


class NamedException : public Exception 
{
public:
  NamedException(const std::string& name);

  const std::string& getName() const {return name_;}

private:
  const std::string name_;
};


class UnrecognisedParameterException : public NamedException 
{
public: 
  UnrecognisedParameterException(const std::string& name) : NamedException(name) {}
};


class AttemptedRecreationOfParameterException : public NamedException 
{
public: 
  AttemptedRecreationOfParameterException(const std::string& name);
};




class ParameterBase
{
public:
  ParameterBase(const std::string& s, 
                const std::string& d  
               ) : s_(s), d_(d) {}
  virtual ~ParameterBase() {}

  const std::string& getS() const {return s_;}
  const std::string& getD() const {return d_;}

  void print(size_t smw, size_t tmw, size_t dmw) const {print_v(smw,tmw,dmw);}
  void read(std::istream& is) {read_v(is);}

protected:
  virtual void  read_v(std::istream&)                = 0;

private:
  virtual void print_v(size_t, size_t, size_t) const = 0;

  const std::string s_; // as appearing in command line
  const std::string d_; // short description

};



template<typename T>
class Parameter : public ParameterBase 
{
public:
  Parameter(const std::string& s, 
            const std::string& d, 
            const T& v 
           ) : ParameterBase(s,d), v_(v) {}

  const T& get() const {return v_;}
        T& get()       {return const_cast<T&>(static_cast<const Parameter*>(this)->get());}

protected:
  void read_v(std::istream& is) {is>>v_;}

private:
  void print_v(size_t smw, size_t tmw, size_t dmw) const;
  
  T v_;
  
};



class ParameterTable
{
public:
  typedef std::shared_ptr<std::string> ParsedCommandLine; 

  ParameterTable() : table_(), smwidth_(0), tmwidth_(6), dmwidth_(0), stream_(), parsedCommandLine_(std::make_shared<std::string>("")) {} // tmwidth_ cf bool!


  const ParameterBase& operator[](const std::string&  ) const; 
        ParameterBase& operator[](const std::string& s)        {return const_cast<ParameterBase&>(static_cast<const ParameterTable&>(*this)[s]);} 




  template<typename T> T& add(const std::string& s, 
                              const std::string& d, 
                              const T& v 
                             );
  
  

  bool& add(const std::string& s, const std::string& d, bool v);


  template<typename T> T& addMod(const std::string& s, const std::string& mod, const std::string& d, const T& v)
  {
    return add(s+mod,d,v);
  }

  ParameterTable& addTitle(const std::string& s, const std::string& mod="");
  

  void printList() const;
  
  std::stringstream& getStream() {return stream_;}

  const ParsedCommandLine getParsedCommandLine(                    ) const {return  parsedCommandLine_;}

  void                    setParsedCommandLine(const std::string& s)       {        *parsedCommandLine_=s;}

private:
  typedef boost::ptr_list<ParameterBase> Impl;

  Impl table_;

  size_t smwidth_; // maximal width of s_ entries
  size_t tmwidth_; // maximal width of typeIDs
  size_t dmwidth_; // maximal width of d_ entries

  std::stringstream stream_;

  ParsedCommandLine parsedCommandLine_;

};


} // parameters


#endif // CPPQEDCORE_UTILS_PARS_H_INCLUDED