scope.hpp

#ifndef HALCHECK_LIB_SCOPE_HPP
#define HALCHECK_LIB_SCOPE_HPP
 
#include <halcheck/lib/functional.hpp>
#include <halcheck/lib/optional.hpp>
#include <halcheck/lib/type_traits.hpp>
#include <halcheck/lib/utility.hpp>
 
#include <cstddef>
#include <type_traits>
 
namespace halcheck { namespace lib {
 
template<typename F = lib::move_only_function<void() &&>>
class finally_t {
public:
  static_assert(lib::is_invocable<F &&>(), "F && should be invocable");
 
// TODO: fix check on MSVC
#ifndef _MSC_VER
  static_assert(std::is_nothrow_move_constructible<F>(), "F should be nothrow move constructible");
#endif
 
  template<typename G>
  friend class finally_t;
 
  constexpr finally_t() = default;
 
  constexpr explicit finally_t(F func) noexcept(std::is_nothrow_move_constructible<F>())
      : _func(lib::in_place, std::move(func)) {}
 
  finally_t(finally_t &&other) noexcept(std::is_nothrow_move_constructible<F>()) : _func(std::move(other._func)) {
    other._func.reset();
  }
 
  template<typename G, HALCHECK_REQUIRE(std::is_convertible<G, F>())>
  finally_t(finally_t<G> &&other) noexcept(std::is_constructible<F, G>()) // NOLINT: implicit conversion
      : _func(std::move(other._func)) {
    other._func.reset();
  }
 
  template<typename G, HALCHECK_REQUIRE(!std::is_convertible<G, F>()), HALCHECK_REQUIRE(std::is_constructible<F, G>())>
  explicit finally_t(finally_t<G> &&other) noexcept(std::is_constructible<F, G>()) : _func(std::move(other._func)) {
    other._func.reset();
  }
 
  finally_t(const finally_t &) = delete;
  finally_t &operator=(const finally_t &) = delete;
  finally_t &operator=(finally_t &&) = delete;
  void *operator new(std::size_t) = delete;
  void *operator new[](std::size_t) = delete;
 
  ~finally_t() noexcept {
    if (_func)
      lib::invoke(std::move(*_func));
  }
 
private:
  template<typename G>
  struct combine {
    lib::optional<F> first;
    lib::optional<G> second;
 
    void operator()() {
      if (second)
        lib::invoke(std::move(*second));
      if (first)
        lib::invoke(std::move(*first));
    }
  };
 
  template<typename G>
  finally_t<combine<G>> make_combined(finally_t<G> &&other) && {
    if (!_func && !other._func)
      return finally_t<combine<G>>();
 
    combine<G> func{std::move(_func), std::move(other._func)};
    _func.reset();
    other._func.reset();
    return finally_t<combine<G>>(std::move(func));
  }
 
  template<typename G>
  friend finally_t<combine<G>> operator+(finally_t &&lhs, finally_t<G> &&rhs) {
    return std::move(lhs).make_combined(std::move(rhs));
  }
 
  lib::optional<F> _func;
};
 
template<typename F, HALCHECK_REQUIRE(lib::is_invocable<F>())>
lib::finally_t<F> finally(F func) {
  return lib::finally_t<F>(std::move(func));
}
 
}} // namespace halcheck::lib
 
#endif