Delegate.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Delegate.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2021 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Utilities/TypeTraits.hpp"

#include <cassert>
#include <functional>
#include <memory>
#include <type_traits>

namespace Acts {

enum class DelegateType { Owning, NonOwning };

// Specialization needed for defaulting ownership and for R(Args...) syntax
template <typename, typename H = void, DelegateType = DelegateType::NonOwning>
class Delegate;

template <typename R, typename H, DelegateType O, typename... Args>
class Delegate<R(Args...), H, O> {
  static constexpr DelegateType kOwnership = O;

  using return_type = R;
  using holder_type = H;
  using function_type = return_type (*)(const holder_type *, Args...);

  using function_ptr_type = return_type (*)(Args...);

  using deleter_type = void (*)(const holder_type *);

  template <typename T, typename C>
  using isSignatureCompatible =
      decltype(std::declval<T &>() = std::declval<C>());

  using OwningDelegate =
      Delegate<R(Args...), holder_type, DelegateType::Owning>;
  using NonOwningDelegate =
      Delegate<R(Args...), holder_type, DelegateType::NonOwning>;
  template <typename T>
  using isNoFunPtr = std::enable_if_t<
      not std::is_convertible_v<std::decay_t<T>, function_type> and
      not std::is_same_v<std::decay_t<T>, OwningDelegate> and
      not std::is_same_v<std::decay_t<T>, NonOwningDelegate>>;

 public:
  Delegate() = default;

  Delegate(Delegate &&) = default;
  Delegate &operator=(Delegate &&) = default;
  Delegate(const Delegate &) = default;
  Delegate &operator=(const Delegate &) = default;

  Delegate(function_type callable) { connect(callable); }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  Delegate(Callable &callable) {
    connect(callable);
  }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  Delegate(Callable &&) = delete;

  void operator=(function_type callable) { connect(callable); }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  void operator=(Callable &callable) {
    connect(callable);
  }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  void operator=(Callable &&) = delete;

  template <auto Callable>
  void connect() {
    m_payload.payload = nullptr;

    static_assert(
        Concepts::is_detected<isSignatureCompatible, function_ptr_type,
                              decltype(Callable)>::value,
        "Callable given does not correspond exactly to required call "
        "signature");

    m_function = [](const holder_type * /*payload*/,
                    Args... args) -> return_type {
      return std::invoke(Callable, std::forward<Args>(args)...);
    };
  }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  void connect(Callable &callable) {
    connect<&Callable::operator(), Callable>(&callable);
  }

  template <typename Callable, typename = isNoFunPtr<Callable>>
  void connect(Callable &&) = delete;

  void connect(function_type callable) {
    if constexpr (kOwnership == DelegateType::NonOwning) {
      m_payload.payload = nullptr;
    }
    m_function = callable;
  }

  template <auto Callable, typename Type, DelegateType T = kOwnership,
            typename = std::enable_if_t<T == DelegateType::NonOwning>>
  void connect(const Type *instance) {
    using member_ptr_type = return_type (Type::*)(Args...) const;

    static_assert(Concepts::is_detected<isSignatureCompatible, member_ptr_type,
                                        decltype(Callable)>::value,
                  "Callable given does not correspond exactly to required call "
                  "signature");

    m_payload.payload = instance;

    m_function = [](const holder_type *payload, Args... args) -> return_type {
      assert(payload != nullptr && "Payload is required, but not set");
      const auto *concretePayload = static_cast<const Type *>(payload);
      return std::invoke(Callable, concretePayload,
                         std::forward<Args>(args)...);
    };
  }

  template <auto Callable, typename Type>
  void connect(std::unique_ptr<const Type> instance) {
    using member_ptr_type = return_type (Type::*)(Args...) const;
    static_assert(Concepts::is_detected<isSignatureCompatible, member_ptr_type,
                                        decltype(Callable)>::value,
                  "Callable given does not correspond exactly to required call "
                  "signature");

    if constexpr (kOwnership == DelegateType::Owning) {
      m_payload.payload = std::unique_ptr<const holder_type, deleter_type>(
          instance.release(), [](const holder_type *payload) {
            const auto *concretePayload = static_cast<const Type *>(payload);
            delete concretePayload;
          });
    } else {
      m_payload.payload = instance.release();
    }

    m_function = [](const holder_type *payload, Args... args) -> return_type {
      assert(payload != nullptr && "Payload is required, but not set");
      const auto *concretePayload = static_cast<const Type *>(payload);
      return std::invoke(Callable, concretePayload,
                         std::forward<Args>(args)...);
    };
  }

  return_type operator()(Args... args) const {
    assert(connected() && "Delegate is not connected");
    return std::invoke(m_function, m_payload.ptr(),
                       std::forward<Args>(args)...);
  }

  bool connected() const { return m_function != nullptr; }

  operator bool() const { return connected(); }

  void disconnect() {
    m_payload.clear();
    m_function = nullptr;
  }

  template <typename holder_t = holder_type,
            typename = std::enable_if_t<!std::is_same_v<holder_t, void>>>
  const holder_type *instance() const {
    return m_payload.ptr();
  }

 private:
  // Deleter that does not do anything
  static void noopDeleter(const holder_type * /*unused*/) {}


  // Payload object without a deleter
  struct NonOwningPayload {
    void clear() { payload = nullptr; }

    const holder_type *ptr() const { return payload; }

    const holder_type *payload{nullptr};
  };

  // Payload object with a deleter
  struct OwningPayload {
    void clear() { payload.reset(); }

    const holder_type *ptr() const { return payload.get(); }

    std::unique_ptr<const holder_type, deleter_type> payload{nullptr,
                                                             &noopDeleter};
  };

  std::conditional_t<kOwnership == DelegateType::NonOwning, NonOwningPayload,
                     OwningPayload>
      m_payload;


  function_type m_function{nullptr};
};

template <typename, typename H = void>
class OwningDelegate;

template <typename R, typename H, typename... Args>
class OwningDelegate<R(Args...), H>
    : public Delegate<R(Args...), H, DelegateType::Owning> {};

}  // namespace Acts