ArgumentPack.h

Go to the documentation of this file.

#ifndef AMPGEN_ARGUMENTPACK_H
#define AMPGEN_ARGUMENTPACK_H
 
#include "AmpGen/MetaUtils.h"
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
namespace AmpGen
{
  #define DECLARE_ARGUMENT(X, Y)                          \
  struct X : public AmpGen::Argument<Y> {                 \
    template<class Z>                                     \
    explicit X(Z val = Z()) : AmpGen::Argument<Y>(val){}  \
    X() : AmpGen::Argument<Y>(){}                         \
  }
 
  struct IArgument {
    virtual ~IArgument() = default; 
  };
  
  template <typename TYPE>
  struct Argument : public IArgument 
  {
    template <typename T>
    explicit Argument( T x ) : val(x) {}
    Argument() = default;
    operator TYPE() const { return val; }
    TYPE val = { TYPE() };
  };

  class ArgumentPack
  {
    public:
      template <typename... ARGS>
        explicit ArgumentPack( const ARGS&... args )
        {
          std::tuple<ARGS...> argTuple( args... );
          for_each(argTuple, [this](const auto& f){ this->addArgument(f) ; } );
        }
      template <typename arg_type> arg_type* get() const 
      {
        for( const auto& param : m_parameters )
        {
          auto ptr = dynamic_cast<arg_type*>(param.get());
          if( ptr != nullptr ) return ptr;
        }
        return nullptr;
      }
      template <typename arg_type, typename default_arg_type=arg_type> 
        arg_type getArg( const default_arg_type& default_argument = default_arg_type() ) const
      {
        auto p = get<arg_type>();
        return p == nullptr ? arg_type(default_argument) : *p;
      }
    private:
      std::vector<std::shared_ptr<IArgument>> m_parameters;
      template <typename T> void addArgument( const T& f ){ m_parameters.emplace_back( std::make_shared<T>(f) ) ; } 
  };
} // namespace AmpGen
 
#endif