BlackMATov/defer.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/defer.hpp.git synced 2025-12-13 07:25:39 +07:00
Code Issues Packages Projects Releases Wiki Activity

little impl renaming

Browse Source
This commit is contained in:
BlackMATov
2023-03-01 16:47:26 +07:00
parent 57d0033c6b
commit 37fa6717c3
1 changed files with 102 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
headers/defer.hpp/defer.hpp
View File

@@ -11,143 +11,140 @@
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
namespace defer_hpp::impl
{
template < typename F, typename... Args >
class defer_impl {
public:
defer_impl() = delete;
defer_impl(defer_impl&&) = delete;
defer_impl(const defer_impl&) = delete;
defer_impl& operator=(defer_impl&&) = delete;
defer_impl& operator=(const defer_impl&) = delete;
template < typename UF >
explicit defer_impl(UF&& f, std::tuple<Args...>&& args)
: f_{std::forward<UF>(f)}
, args_{std::move(args)} {}
void dismiss() noexcept {
dismissed_ = true;
}
protected:
~defer_impl() noexcept {
if ( !dismissed_ ) {
std::apply(std::move(f_), std::move(args_));
}
}
private:
F f_;
std::tuple<Args...> args_;
bool dismissed_{};
};
}
namespace defer_hpp namespace defer_hpp
{ {
namespace impl template < typename F, typename... Args >
{ class defer final : public impl::defer_impl<F, Args...> {
template < typename F, typename... Args > public:
class base_defer_t { defer() = delete;
public: defer(defer&&) = delete;
base_defer_t() = delete; defer(const defer&) = delete;
base_defer_t(base_defer_t&&) = delete; defer& operator=(defer&&) = delete;
base_defer_t(const base_defer_t&) = delete; defer& operator=(const defer&) = delete;
base_defer_t& operator=(base_defer_t&&) = delete;
base_defer_t& operator=(const base_defer_t&) = delete;
template < typename UF > template < typename UF >
explicit base_defer_t(UF&& f, std::tuple<Args...>&& args) explicit defer(UF&& f, std::tuple<Args...>&& args)
: f_{std::forward<UF>(f)} : impl::defer_impl<F, Args...>{std::forward<UF>(f), std::move(args)} {}
, args_{std::move(args)} {}
void dismiss() noexcept { ~defer() noexcept = default;
dismissed_ = true; };
template < typename F, typename... Args >
class error_defer final : public impl::defer_impl<F, Args...> {
public:
error_defer() = delete;
error_defer(error_defer&&) = delete;
error_defer(const error_defer&) = delete;
error_defer& operator=(error_defer&&) = delete;
error_defer& operator=(const error_defer&) = delete;
template < typename UF >
explicit error_defer(UF&& f, std::tuple<Args...>&& args)
: impl::defer_impl<F, Args...>{std::forward<UF>(f), std::move(args)}
, exceptions_{std::uncaught_exceptions()} {}
~error_defer() noexcept {
if ( exceptions_ == std::uncaught_exceptions() ) {
this->dismiss();
} }
}
protected: private:
~base_defer_t() noexcept { int exceptions_{};
if ( !dismissed_ ) { };
std::apply(std::move(f_), std::move(args_));
} template < typename F, typename... Args >
class return_defer final : public impl::defer_impl<F, Args...> {
public:
return_defer() = delete;
return_defer(return_defer&&) = delete;
return_defer(const return_defer&) = delete;
return_defer& operator=(return_defer&&) = delete;
return_defer& operator=(const return_defer&) = delete;
template < typename UF >
explicit return_defer(UF&& f, std::tuple<Args...>&& args)
: impl::defer_impl<F, Args...>{std::forward<UF>(f), std::move(args)}
, exceptions_{std::uncaught_exceptions()} {}
~return_defer() noexcept {
if ( exceptions_ != std::uncaught_exceptions() ) {
this->dismiss();
} }
}
private: private:
F f_; int exceptions_{};
std::tuple<Args...> args_; };
bool dismissed_{};
};
}
namespace impl
{
template < typename F, typename... Args >
class defer_t final : public base_defer_t<F, Args...> {
public:
defer_t() = delete;
defer_t(defer_t&&) = delete;
defer_t(const defer_t&) = delete;
defer_t& operator=(defer_t&&) = delete;
defer_t& operator=(const defer_t&) = delete;
template < typename UF >
explicit defer_t(UF&& f, std::tuple<Args...>&& args)
: base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)} {}
~defer_t() noexcept = default;
};
template < typename F, typename... Args >
class error_defer_t final : public base_defer_t<F, Args...> {
public:
error_defer_t() = delete;
error_defer_t(error_defer_t&&) = delete;
error_defer_t(const error_defer_t&) = delete;
error_defer_t& operator=(error_defer_t&&) = delete;
error_defer_t& operator=(const error_defer_t&) = delete;
template < typename UF >
explicit error_defer_t(UF&& f, std::tuple<Args...>&& args)
: base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)}
, exceptions_{std::uncaught_exceptions()} {}
~error_defer_t() noexcept {
if ( exceptions_ == std::uncaught_exceptions() ) {
this->dismiss();
}
}
private:
int exceptions_{};
};
template < typename F, typename... Args >
class return_defer_t final : public base_defer_t<F, Args...> {
public:
return_defer_t() = delete;
return_defer_t(return_defer_t&&) = delete;
return_defer_t(const return_defer_t&) = delete;
return_defer_t& operator=(return_defer_t&&) = delete;
return_defer_t& operator=(const return_defer_t&) = delete;
template < typename UF >
explicit return_defer_t(UF&& f, std::tuple<Args...>&& args)
: base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)}
, exceptions_{std::uncaught_exceptions()} {}
~return_defer_t() noexcept {
if ( exceptions_ != std::uncaught_exceptions() ) {
this->dismiss();
}
}
private:
int exceptions_{};
};
}
template < typename F, typename... Args > template < typename F, typename... Args >
auto make_defer(F&& f, Args&&... args) { auto make_defer(F&& f, Args&&... args) {
using defer_t = impl::defer_t<std::decay_t<F>, std::decay_t<Args>...>; using defer_t = defer<std::decay_t<F>, std::decay_t<Args>...>;
return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)}; return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
} }
template < typename F, typename... Args > template < typename F, typename... Args >
auto make_error_defer(F&& f, Args&&... args) { auto make_error_defer(F&& f, Args&&... args) {
using defer_t = impl::error_defer_t<std::decay_t<F>, std::decay_t<Args>...>; using defer_t = error_defer<std::decay_t<F>, std::decay_t<Args>...>;
return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)}; return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
} }
template < typename F, typename... Args > template < typename F, typename... Args >
auto make_return_defer(F&& f, Args&&... args) { auto make_return_defer(F&& f, Args&&... args) {
using defer_t = impl::return_defer_t<std::decay_t<F>, std::decay_t<Args>...>; using defer_t = return_defer<std::decay_t<F>, std::decay_t<Args>...>;
return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)}; return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
} }
} }
#define DEFER_HPP_IMPL_PP_CAT(x, y) DEFER_HPP_IMPL_PP_CAT_I(x, y) #define DEFER_HPP_PP_CAT(x, y) DEFER_HPP_PP_CAT_I(x, y)
#define DEFER_HPP_IMPL_PP_CAT_I(x, y) x##y #define DEFER_HPP_PP_CAT_I(x, y) x##y
#ifdef __COUNTER__ #ifdef __COUNTER__
# define DEFER_HPP(...) \ # define DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __COUNTER__) { ::defer_hpp::make_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_defer_, __COUNTER__) { ::defer_hpp::make_defer(__VA_ARGS__) }
# define ERROR_DEFER_HPP(...) \ # define ERROR_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_error_defer_, __COUNTER__) { ::defer_hpp::make_error_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_error_defer_, __COUNTER__) { ::defer_hpp::make_error_defer(__VA_ARGS__) }
# define RETURN_DEFER_HPP(...) \ # define RETURN_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __COUNTER__) { ::defer_hpp::make_return_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_return_defer_, __COUNTER__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
#else #else
# define DEFER_HPP(...) \ # define DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __LINE__) { ::defer_hpp::make_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_defer_, __LINE__) { ::defer_hpp::make_defer(__VA_ARGS__) }
# define ERROR_DEFER_HPP(...) \ # define ERROR_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_error_defer_, __LINE__) { ::defer_hpp::make_error_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_error_defer_, __LINE__) { ::defer_hpp::make_error_defer(__VA_ARGS__) }
# define RETURN_DEFER_HPP(...) \ # define RETURN_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __LINE__) { ::defer_hpp::make_return_defer(__VA_ARGS__) } auto DEFER_HPP_PP_CAT(defer_hpp_generated_return_defer_, __LINE__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
#endif #endif