SolvingRequirements.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/requirements/AnisotropicWeight.h>
#include <tvm/requirements/PriorityLevel.h>
#include <tvm/requirements/ViolationEvaluation.h>
#include <tvm/requirements/Weight.h>
 
#include <Eigen/Core>
 
namespace tvm
{
 
namespace requirements
{
 
#define ADD_REQUIREMENT(T, name, member)                                                             \
public:                                                                                              \
  const T<Lightweight> & name() const { return member; }                                             \
  T<Lightweight> & name() { return member; }                                                         \
                                                                                                     \
private:                                                                                             \
  T<Lightweight> member;                                                                             \
  template<typename... Args>                                                                         \
  void build(const T<Lightweight> & m, const Args &... args)                                         \
  {                                                                                                  \
    static_assert(!check_args<T<Lightweight>, Args...>() && !check_args<T<!Lightweight>, Args...>(), \
                  #T " has already been specified");                                                 \
    member = m;                                                                                      \
    build(args...);                                                                                  \
  }                                                                                                  \
  template<typename... Args>                                                                         \
  void build(const T<!Lightweight> & m, const Args &... args)                                        \
  {                                                                                                  \
    static_assert(!check_args<T<Lightweight>, Args...>() && !check_args<T<!Lightweight>, Args...>(), \
                  #T " has already been specified");                                                 \
    member = m;                                                                                      \
    build(args...);                                                                                  \
  }
 
template<bool Lightweight = true>
class SolvingRequirementsBase
{
public:
  template<typename... Args>
  SolvingRequirementsBase(const Args &... args)
  { build(args...); }
 
private:
  template<typename T, typename Arg0, typename... Args>
  static constexpr bool check_args()
  { return std::is_same<T, Arg0>::value || check_args<T, Args...>(); }
 
  template<typename T>
  static constexpr bool check_args()
  { return false; }
 
  ADD_REQUIREMENT(PriorityLevelBase, priorityLevel, priority_)
  ADD_REQUIREMENT(WeightBase, weight, weight_)
  ADD_REQUIREMENT(AnisotropicWeightBase, anisotropicWeight, aWeight_)
  ADD_REQUIREMENT(ViolationEvaluationBase, violationEvaluation, evalType_)
 
  void build() {}
};
 
class SolvingRequirements : public SolvingRequirementsBase<true>
{
  using SolvingRequirementsBase::SolvingRequirementsBase;
};
 
class SolvingRequirementsWithCallbacks : public SolvingRequirementsBase<false>
{
public:
  using SolvingRequirementsBase::SolvingRequirementsBase;
  SolvingRequirementsWithCallbacks(const SolvingRequirementsWithCallbacks &) = delete;
  SolvingRequirementsWithCallbacks & operator=(const SolvingRequirementsWithCallbacks &) = delete;
 
  explicit SolvingRequirementsWithCallbacks(const SolvingRequirements & req)
  : SolvingRequirementsBase(req.priorityLevel(), req.weight(), req.anisotropicWeight(), req.violationEvaluation())
  {}
};
 
#undef ADD_REQUIREMENT
 
} // namespace requirements
 
} // namespace tvm