chain_first.h

Go to the documentation of this file.

#ifndef FWCore_Concurrency_chain_first_h
#define FWCore_Concurrency_chain_first_h
// -*- C++ -*-
//
// Package:     Concurrency
// function  :     edm::waiting_task::chain::first
//
//
// Original Author:  Chris Jones
//         Created:  Thu Feb 21 13:46:31 CST 2013
// $Id$
//

// system include files
#include <atomic>
#include <exception>
#include <memory>
#include <type_traits>

// user include files
#include "FWCore/Concurrency/interface/WaitingTaskHolder.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"

// forward declarations

namespace edm {
  namespace waiting_task::detail {

    template <class, class = void>
    struct has_exception_handling : std::false_type {};

    template <class T>
    struct has_exception_handling<T,
                                  std::void_t<decltype(std::declval<T&>()(
                                      static_cast<std::exception_ptr const*>(nullptr), edm::WaitingTaskHolder()))>>
        : std::true_type {};

    template <typename F>
    struct AutoExceptionHandler {
      AutoExceptionHandler(F&& iF) : f_{std::forward<F>(iF)} {}

      void operator()(std::exception_ptr const* iPtr, edm::WaitingTaskHolder h) noexcept {
        if (iPtr) {
          h.doneWaiting(*iPtr);
        } else {
          CMS_SA_ALLOW try { f_(h); } catch (...) {
            h.doneWaiting(std::current_exception());
          }
        }
      }

    private:
      F f_;
    };

    template <typename E, typename F>
    struct ExplicitExceptionHandler {
      ExplicitExceptionHandler(E&& iE, F&& iF) : except_(std::forward<E>(iE)), f_{std::forward<F>(iF)} {}

      void operator()(std::exception_ptr const* iPtr, edm::WaitingTaskHolder h) noexcept {
        if (iPtr) {
          except_(*iPtr);
          h.doneWaiting(*iPtr);
        } else {
          CMS_SA_ALLOW try { f_(h); } catch (...) {
            h.doneWaiting(std::current_exception());
          }
        }
      }

    private:
      E except_;
      F f_;
    };

    template <typename E>
    struct IfExceptionAdapter {
      constexpr IfExceptionAdapter(E&& iE) : except_(std::forward<E>(iE)) {}

      template <typename F>
      constexpr auto else_(F&& iF) {
        return ExplicitExceptionHandler<E, F>(std::move(except_), std::forward<F>(iF));
      }

    private:
      E except_;
    };

    template <typename... T>
    struct WaitingTaskChain;

    template <typename F>
    struct Conditional {};

    template <typename F>
    struct ConditionalAdaptor {
      constexpr explicit ConditionalAdaptor(bool iCond, F&& iF) : f_(std::forward<F>(iF)), condition_(iCond) {}

      template <typename... T>
      [[nodiscard]] constexpr auto pipe(WaitingTaskChain<T...> iChain) {
        return WaitingTaskChain<Conditional<F>, T...>(condition_, std::move(f_), std::move(iChain));
      }

      F f_;
      bool condition_;
    };

    template <typename F>
    struct ThenAdaptor {
      constexpr explicit ThenAdaptor(F&& iF) : f_(std::forward<F>(iF)) {}

      template <typename... T>
      [[nodiscard]] constexpr auto pipe(WaitingTaskChain<T...> iChain) {
        return WaitingTaskChain<F, T...>(std::move(f_), std::move(iChain));
      }

    private:
      F f_;
    };

    struct RunLastAdaptor {
      explicit RunLastAdaptor(edm::WaitingTaskHolder iT) : task_(std::move(iT)) {}

      template <typename... T>
      constexpr void pipe(WaitingTaskChain<T...>&& iChain) {
        iChain.runLast(std::move(task_));
      }

    private:
      edm::WaitingTaskHolder task_;
    };

    struct LastTaskAdaptor {
      explicit LastTaskAdaptor(edm::WaitingTaskHolder iT) : task_(std::move(iT)) {}

      template <typename... T>
      constexpr auto pipe(WaitingTaskChain<T...>&& iChain) {
        return iChain.lastTask(std::move(task_));
      }

    private:
      edm::WaitingTaskHolder task_;
    };

    template <typename U>
    struct WaitingTaskChain<U> {
      constexpr explicit WaitingTaskChain(U&& iU) : f_{std::forward<U>(iU)} {}

      [[nodiscard]] WaitingTaskHolder lastTask(WaitingTaskHolder iV) {
        return WaitingTaskHolder(
            *iV.group(),
            make_waiting_task([f = std::move(f_), v = std::move(iV)](const std::exception_ptr* iPtr) mutable {
              f(iPtr, std::move(v));
            }));
      }

      void runLast(WaitingTaskHolder iH) { f_(nullptr, std::move(iH)); }

      template <typename V>
      friend auto operator|(WaitingTaskChain<U> iChain, V&& iV) {
        return iV.pipe(std::move(iChain));
      }

    private:
      U f_;
    };

    template <typename U, typename... T>
    struct WaitingTaskChain<U, T...> {
      explicit constexpr WaitingTaskChain(U&& iU, WaitingTaskChain<T...> iL)
          : l_(std::move(iL)), f_{std::forward<U>(iU)} {}

      [[nodiscard]] WaitingTaskHolder lastTask(WaitingTaskHolder iV) {
        return l_.lastTask(WaitingTaskHolder(
            *iV.group(),
            make_waiting_task([f = std::move(f_), v = std::move(iV)](std::exception_ptr const* iPtr) mutable {
              f(iPtr, std::move(v));
            })));
      }

      void runLast(WaitingTaskHolder iV) {
        l_.runLast(WaitingTaskHolder(
            *iV.group(),
            make_waiting_task([f = std::move(f_), v = std::move(iV)](std::exception_ptr const* iPtr) mutable {
              f(iPtr, std::move(v));
            })));
      }

      template <typename V>
      friend auto operator|(WaitingTaskChain<U, T...> iChain, V&& iV) {
        return iV.pipe(std::move(iChain));
      }

    private:
      WaitingTaskChain<T...> l_;
      U f_;
    };

    template <typename U, typename... T>
    struct WaitingTaskChain<Conditional<U>, T...> {
      explicit constexpr WaitingTaskChain(bool iCondition, U&& iU, WaitingTaskChain<T...> iL)
          : l_(std::move(iL)), f_{std::forward<U>(iU)}, condition_(iCondition) {}

      explicit constexpr WaitingTaskChain(Conditional<U> iC, WaitingTaskChain<T...> iL)
          : l_(std::move(iL)), f_{std::move<U>(iC.f_)}, condition_(iC.condition_) {}

      [[nodiscard]] WaitingTaskHolder lastTask(WaitingTaskHolder iV) {
        if (condition_) {
          return l_.lastTask(WaitingTaskHolder(
              *iV.group(),
              make_waiting_task([f = std::move(f_), v = std::move(iV)](std::exception_ptr const* iPtr) mutable {
                f(iPtr, std::move(v));
              })));
        }
        return l_.lastTask(iV);
      }

      void runLast(WaitingTaskHolder iV) {
        if (condition_) {
          l_.runLast(WaitingTaskHolder(
              *iV.group(),
              make_waiting_task([f = std::move(f_), v = std::move(iV)](std::exception_ptr const* iPtr) mutable {
                f(iPtr, std::move(v));
              })));
        } else {
          l_.runLast(iV);
        }
      }

      template <typename V>
      friend auto operator|(WaitingTaskChain<Conditional<U>, T...> iChain, V&& iV) {
        return iV.pipe(std::move(iChain));
      }

    private:
      WaitingTaskChain<T...> l_;
      U f_;
      bool condition_;
    };

  }  // namespace waiting_task::detail
  namespace waiting_task::chain {

    template <typename F>
    [[nodiscard]] constexpr auto first(F&& iF) {
      using namespace detail;
      if constexpr (has_exception_handling<F>::value) {
        return WaitingTaskChain<F>(std::forward<F>(iF));
      } else {
        return WaitingTaskChain<AutoExceptionHandler<F>>(AutoExceptionHandler<F>(std::forward<F>(iF)));
      }
    }

    template <typename O>
    [[nodiscard]] constexpr auto then(O&& iO) {
      using namespace detail;
      if constexpr (has_exception_handling<O>::value) {
        return ThenAdaptor<O>(std::forward<O>(iO));
      } else {
        return ThenAdaptor<AutoExceptionHandler<O>>(AutoExceptionHandler<O>(std::forward<O>(iO)));
      }
    }

    template <typename O>
    [[nodiscard]] constexpr auto ifThen(bool iValue, O&& iO) {
      using namespace detail;
      if constexpr (has_exception_handling<O>::value) {
        return ConditionalAdaptor<O>(iValue, std::forward<O>(iO));
      } else {
        return ConditionalAdaptor<AutoExceptionHandler<O>>(iValue, AutoExceptionHandler<O>(std::forward<O>(iO)));
      }
    }

    [[nodiscard]] inline auto runLast(edm::WaitingTaskHolder iTask) { return detail::RunLastAdaptor(std::move(iTask)); }

    [[nodiscard]] inline auto lastTask(edm::WaitingTaskHolder iTask) {
      return detail::LastTaskAdaptor(std::move(iTask));
    }

    template <typename E>
    [[nodiscard]] constexpr auto ifException(E&& iE) {
      return detail::IfExceptionAdapter(std::forward<E>(iE));
    }

  }  // namespace waiting_task::chain
}  // namespace edm

#endif