exec_policy.h

#ifndef ADIAR_EXEC_POLICY_H
#define ADIAR_EXEC_POLICY_H
 
#include <algorithm>
#include <limits>
 
#include <adiar/type_traits.h>
 
namespace adiar
{
 
  class exec_policy
  {
  public:
    enum class access : char
    {
      Auto,
      Random_Access,
      Priority_Queue
    };
 
    enum class memory : char
    {
      Auto,
      Internal,
      External
    };
 
    class quantify
    {
    public:
      enum algorithm : char
      {
        Nested,
        Singleton
      };
    };
 
  private:
    // TODO: Merge all enums into a single 64 bit integer to safe on space?
 
    access _access = access::Auto;
 
    memory _memory = memory::Auto;
 
    quantify::algorithm _quantify__algorithm = quantify::Nested;
 
  public:
    exec_policy() = default;
 
    exec_policy(const exec_policy&) = default;
 
    exec_policy(exec_policy&&) = default;
 
    exec_policy(const access& am)
      : _access(am)
    {}
 
    exec_policy(const memory& mm)
      : _memory(mm)
    {}
 
    exec_policy(const quantify::algorithm& qa)
      : _quantify__algorithm(qa)
    {}
 
    // TODO: constructor with defaults for a specific 'version number'?
 
  public:
    exec_policy&
    operator=(const exec_policy&) = default;
 
    exec_policy&
    operator=(exec_policy&&) = default;
 
  public:
    template <typename T>
    const T&
    get() const;
 
  public:
    bool
    operator==(const exec_policy& ep) const
    {
      // Order based from the most generic to the most specific setting.
      return this->_memory == ep._memory && this->_access == ep._access
        && this->_quantify__algorithm == ep._quantify__algorithm;
    }
 
    bool
    operator!=(const exec_policy& ep) const
    {
      return !(*this == ep);
    }
 
  public:
    exec_policy&
    set(const access& am)
    {
      this->_access = am;
      return *this;
    }
 
    exec_policy
    operator&(const access& am) const
    {
      exec_policy ep = *this;
      return ep.set(am);
    }
 
    exec_policy&
    set(const memory& mm)
    {
      this->_memory = mm;
      return *this;
    }
 
    exec_policy
    operator&(const memory& mm) const
    {
      exec_policy ep = *this;
      return ep.set(mm);
    }
 
    exec_policy&
    set(const quantify::algorithm& qa)
    {
      this->_quantify__algorithm = qa;
      return *this;
    }
 
    exec_policy
    operator&(const quantify::algorithm& qa) const
    {
      exec_policy ep = *this;
      return ep.set(qa);
    }
  };
 
  template <>
  inline const exec_policy::access&
  exec_policy::get<exec_policy::access>() const
  {
    return this->_access;
  }
 
  template <>
  inline const exec_policy::memory&
  exec_policy::get<exec_policy::memory>() const
  {
    return this->_memory;
  }
 
  template <>
  inline const exec_policy::quantify::algorithm&
  exec_policy::get<exec_policy::quantify::algorithm>() const
  {
    return this->_quantify__algorithm;
  }
 
 
 
  template <
    typename A,
    typename B,
    typename = enable_if<needs_conversion<A, exec_policy> && needs_conversion<B, exec_policy>>>
  exec_policy
  operator&(const A& a, const B& b)
  {
    return exec_policy(a) & b;
  }
 
}
 
#endif // ADIAR_EXEC_POLICY_H