polymorphic_execution.h

Go to the documentation of this file.

#ifndef GRPPI_POLY_POLYMORPHIC_EXECUTION_H
#define GRPPI_POLY_POLYMORPHIC_EXECUTION_H

#include "../seq/sequential_execution.h"
#include "../native/parallel_execution_native.h"
#include "../tbb/parallel_execution_tbb.h"
#include "../omp/parallel_execution_omp.h"

#include <typeinfo>
#include <memory>

namespace grppi{

template <typename E>
constexpr bool is_execution_policy() {
  return is_sequential_execution<E>() 
      || is_parallel_execution_native<E>()
      || is_parallel_execution_tbb<E>()
      || is_parallel_execution_omp<E>()
  ;
}

template <typename E>
using requires_execution_policy =
  std::enable_if_t<is_execution_policy<E>(), int>;

template <typename E>
using requires_not_execution_policy =
  std::enable_if_t<!is_execution_policy<E>(), int>;

// Forward declare polymorphic execution
class polymorphic_execution;

// Forward declare make execution for polymorphic execution
template <typename E>
polymorphic_execution make_polymorphic_execution();

class polymorphic_execution {
public:

  polymorphic_execution() noexcept :
    execution_{},
    execution_type_{nullptr}
  {}

  bool has_execution() const noexcept { return execution_.get() != nullptr; }

  const std::type_info & type() const noexcept { 
    return *execution_type_; 
  }

  // Check if the current execution is of type E
  template <typename E>
  bool is_execution() const {
    if (!has_execution()) return false;
    return typeid(E) == *execution_type_;
  }

  template <typename E, 
            requires_execution_policy<E> = 0>
  E * execution_ptr() {
    if (!has_execution()) return nullptr;
    if (*execution_type_ != typeid(E)) return nullptr;
    return static_cast<E*>(execution_.get());
  }

  template <typename E, 
            requires_not_execution_policy<E> = 0>
  E * execution_ptr() {
    return nullptr;
  }

private:
  std::shared_ptr<void> execution_;

  const std::type_info * execution_type_;

private:

  template <typename E>
  friend polymorphic_execution make_polymorphic_execution() {
    polymorphic_execution e;
    if (!is_supported<E>()) return e;
    e.execution_ = std::make_shared<E>();
    e.execution_type_ = &typeid(E);
    return e;
  }

};

} // end namespace grppi

#endif