OutputSelector.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>
#include <vector>
 
#include <tvm/graph/abstract/Outputs.h>
 
namespace tvm
{
 
namespace graph
{
 
namespace abstract
{
 
template<bool add = true>
struct SelectorMembers
{
  std::vector<bool> dynamicallyEnabled_;
  bool locked_ = false;
};
 
template<>
struct SelectorMembers<false>
{};
 
// forward declaration
template<typename T, typename Base>
class OutputSelector;
 
template<typename T, typename Base>
std::true_type is_output_selector_impl(OutputSelector<T, Base> const volatile &);
 
std::false_type is_output_selector_impl(...);
 
template<typename T>
constexpr bool is_output_selector()
{ return decltype(is_output_selector_impl(std::declval<const T &>()))::value; }
 
template<typename OutputProvider, typename Base = OutputProvider>
class OutputSelector : public Base, protected SelectorMembers<!is_output_selector<Base>()>
{
public:
  template<typename... Args>
  OutputSelector(Args &&... args) : Base(std::forward<Args>(args)...)
  {
    static_assert(std::is_base_of<Outputs, Base>::value, "Cannot build for a type that is not derived of Outputs");
    this->dynamicallyEnabled_.resize(OutputProvider::OutputSize, true);
  }
 
  void lock() { this->locked_ = true; }
 
  void unlock() { this->locked_ = false; }
 
  bool isLocked() const { return this->locked_; }
 
protected:
  template<typename EnumT>
  void disableOutput(EnumT e)
  {
    if(!is_valid_output<OutputProvider>(e))
      throw std::runtime_error("You can only disable outputs that are part of the class.");
 
    if(!this->locked_)
      this->dynamicallyEnabled_[static_cast<size_t>(e)] = false;
    else
      throw std::runtime_error("Outputs have been locked, you cannot disable one.");
  }
 
  template<typename EnumT, typename... Args>
  void disableOutput(EnumT e, Args... args)
  {
    disableOutput(e);
    disableOutput(args...);
  }
 
  template<typename EnumT>
  void enableOutput(EnumT e)
  {
    if(!is_valid_output<OutputProvider>(e))
      throw std::runtime_error("You can only disable outputs that are part of the class.");
 
    if(!this->isOutputStaticallyEnabled(static_cast<int>(e)))
      throw std::runtime_error("You can not enable outputs that are statically disabled.");
 
    if(!this->locked_)
      this->dynamicallyEnabled_[static_cast<size_t>(e)] = true;
    else
      throw std::runtime_error("Outputs have been locked, you cannot enable one.");
  }
 
  template<typename EnumT, typename... Args>
  void enableOutput(EnumT e, Args... args)
  {
    enableOutput(e);
    enableOutput(args...);
  }
 
  bool isOutputCustomEnabled(int e) const override
  {
    if(e < 0 || e >= static_cast<int>(this->dynamicallyEnabled_.size()))
      throw std::runtime_error("Enum value is invalid");
    return this->dynamicallyEnabled_[e];
  }
};
 
} // namespace abstract
 
} // namespace graph
 
} // namespace tvm