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