once_function.h

Go to the documentation of this file.

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
 
#pragma once
 
#include <utility>
 
#include <dispenso/detail/once_callable_impl.h>
#include <dispenso/platform.h>
 
namespace dispenso {
 
#if DISPENSO_HAS_CONCEPTS
template <typename F>
concept OnceCallableFunc = std::invocable<F>;
#endif // DISPENSO_HAS_CONCEPTS
 
namespace detail {
template <typename Result>
class FutureBase;
template <typename Result>
class FutureImplBase;
} // namespace detail
 
class OnceFunction {
 public:
  OnceFunction()
#if defined DISPENSO_DEBUG
      : data_(nullptr),
        invoke_(nullptr)
#endif // DISPENSO_DEBUG
  {
  }
 
  template <typename F>
  DISPENSO_REQUIRES(OnceCallableFunc<F>)
  OnceFunction(F&& f) {
    auto callable = detail::createOnceCallable(std::forward<F>(f));
    data_ = callable.data;
    invoke_ = callable.invoke;
  }
 
  OnceFunction(const OnceFunction& other) = delete;
 
  OnceFunction(OnceFunction&& other) noexcept : data_(other.data_), invoke_(other.invoke_) {
#if defined DISPENSO_DEBUG
    other.data_ = nullptr;
    other.invoke_ = nullptr;
#endif // DISPENSO_DEBUG
  }
 
  OnceFunction& operator=(OnceFunction&& other) noexcept {
    data_ = other.data_;
    invoke_ = other.invoke_;
#if defined DISPENSO_DEBUG
    if (&other != this) {
      other.data_ = nullptr;
      other.invoke_ = nullptr;
    }
#endif // DISPENSO_DEBUG
    return *this;
  }
 
  void cleanupNotRun() const {
#if defined DISPENSO_DEBUG
    assert(data_ != nullptr && "Must not cleanup an invalid OnceFunction!");
    invoke_(data_, false);
    data_ = nullptr;
    invoke_ = nullptr;
#else
    invoke_(data_, false);
#endif // DISPENSO_DEBUG
  }
 
  void operator()() const {
#if defined DISPENSO_DEBUG
    assert(data_ != nullptr && "Must not use OnceFunction more than once!");
#endif // DISPENSO_DEBUG
 
    invoke_(data_, true);
 
#if defined DISPENSO_DEBUG
    data_ = nullptr;
    invoke_ = nullptr;
#endif // DISPENSO_DEBUG
  }
 
 private:
  OnceFunction(detail::OnceCallable* func, bool) : data_(func), invoke_(&detail::runOnceCallable) {}
 
  mutable void* data_;
  void (*invoke_)(void*, bool);
 
  template <typename Result>
  friend class detail::FutureBase;
  template <typename Result>
  friend class detail::FutureImplBase;
};
 
} // namespace dispenso