BLI_function_ref.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <type_traits>
#include <utility>
 
#include "BLI_build_config.h"
#include "BLI_utildefines.h"

 
namespace blender {
 
template<typename Function> class FunctionRef;
 
template<typename Ret, typename... Params> class FunctionRef<Ret(Params...)> {
 private:
  Ret (*callback_)(intptr_t callable, Params... params) = nullptr;

  intptr_t callable_;
 
  template<typename Callable> static Ret callback_fn(intptr_t callable, Params... params)
  {
    return (*reinterpret_cast<Callable *>(callable))(std::forward<Params>(params)...);
  }
 
 public:
  FunctionRef() = default;
 
  FunctionRef(std::nullptr_t) {}

  template<typename Callable,
           BLI_ENABLE_IF((
               !std::is_same_v<std::remove_cv_t<std::remove_reference_t<Callable>>, FunctionRef>)),
           BLI_ENABLE_IF((std::is_invocable_r_v<Ret, Callable, Params...>))>
  FunctionRef(Callable &&callable)
      : callback_(callback_fn<typename std::remove_reference_t<Callable>>),
        callable_(intptr_t(&callable))
  {
    if constexpr (std::is_constructible_v<bool, Callable>) {
      /* For some types, the compiler can be sure that the callable is always truthy. Good!
       * Then the entire check can be optimized away. */
#if COMPILER_CLANG || COMPILER_GCC
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Waddress"
#  if COMPILER_GCC
#    pragma GCC diagnostic ignored "-Wnonnull-compare"
#  endif
#endif
      /* Make sure the #FunctionRef is falsy if the callback is falsy.
       * That can happen when passing in null or empty std::function. */
      const bool is_truthy = bool(callable);
      if (!is_truthy) {
        callback_ = nullptr;
        callable_ = 0;
      }
#if COMPILER_CLANG || COMPILER_GCC
#  pragma GCC diagnostic pop
#endif
    }
  }

  Ret operator()(Params... params) const
  {
    BLI_assert(callback_ != nullptr);
    return callback_(callable_, std::forward<Params>(params)...);
  }

  operator bool() const
  {
    /* Just checking `callback_` is enough to determine if the `FunctionRef` is in a state that it
     * can be called in. */
    return callback_ != nullptr;
  }
};
 
}  // namespace blender