BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-15 11:52:08 +07:00
Code Issues Packages Projects Releases Wiki Activity

remove redundant code

Browse Source
This commit is contained in:
BlackMATov
2023-07-15 05:25:04 +07:00
parent b76de7109f
commit 0fee85e08f
4 changed files with 0 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
develop/singles/headers/meta.hpp/meta_all.hpp
View File

@@ -383,153 +383,6 @@ namespace meta_hpp::detail
using copy_cvref_t = typename copy_cvref<From, To>::type; using copy_cvref_t = typename copy_cvref<From, To>::type;
} }
namespace meta_hpp::detail
{
namespace 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_{};
};
}
template < typename F, typename... Args >
class defer final : public impl::defer_impl<F, Args...> {
public:
defer() = delete;
defer(defer&&) = delete;
defer(const defer&) = delete;
defer& operator=(defer&&) = delete;
defer& operator=(const defer&) = delete;
template < typename UF >
explicit defer(UF&& f, std::tuple<Args...>&& args)
: impl::defer_impl<F, Args...>{std::forward<UF>(f), std::move(args)} {}
~defer() noexcept = default;
};
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();
}
}
private:
int exceptions_{};
};
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:
int exceptions_{};
};
template < typename F, typename... Args >
auto make_defer(F&& f, Args&&... 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)...)};
}
template < typename F, typename... Args >
auto make_error_defer(F&& f, Args&&... 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)...)};
}
template < typename F, typename... Args >
auto make_return_defer(F&& f, Args&&... 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)...)};
}
}
#ifdef __COUNTER__
# define META_HPP_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_defer_, __COUNTER__) { \
::meta_hpp::detail::make_defer(__VA_ARGS__) \
}
# define META_HPP_ERROR_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_error_defer_, __COUNTER__) { \
::meta_hpp::detail::make_error_defer(__VA_ARGS__) \
}
# define META_HPP_RETURN_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_return_defer_, __COUNTER__) { \
::meta_hpp::detail::make_return_defer(__VA_ARGS__) \
}
#else
# define META_HPP_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_defer_, __LINE__) { \
::meta_hpp::detail::make_defer(__VA_ARGS__) \
}
# define META_HPP_ERROR_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_error_defer_, __LINE__) { \
::meta_hpp::detail::make_error_defer(__VA_ARGS__) \
}
# define META_HPP_RETURN_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_return_defer_, __LINE__) { \
::meta_hpp::detail::make_return_defer(__VA_ARGS__) \
}
#endif
#if !defined(META_HPP_NO_EXCEPTIONS) #if !defined(META_HPP_NO_EXCEPTIONS)
# define META_HPP_TRY try # define META_HPP_TRY try
# define META_HPP_CATCH(...) catch ( __VA_ARGS__ ) # define META_HPP_CATCH(...) catch ( __VA_ARGS__ )
@@ -1454,17 +1307,6 @@ namespace meta_hpp::detail
}; };
} }
namespace meta_hpp::detail
{
template < typename... Ts >
struct overloaded : Ts... {
using Ts::operator()...;
};
template < typename... Ts >
overloaded(Ts...) -> overloaded<Ts...>;
}
namespace meta_hpp::detail namespace meta_hpp::detail
{ {
template < typename C, typename R, typename... Args > template < typename C, typename R, typename... Args >

2
headers/meta.hpp/meta_base.hpp
View File

@@ -10,7 +10,6 @@
#include "meta_base/bitflags.hpp" #include "meta_base/bitflags.hpp"
#include "meta_base/cv_traits.hpp" #include "meta_base/cv_traits.hpp"
#include "meta_base/cvref_traits.hpp" #include "meta_base/cvref_traits.hpp"
#include "meta_base/defer.hpp"
#include "meta_base/exceptions.hpp" #include "meta_base/exceptions.hpp"
#include "meta_base/fixed_function.hpp" #include "meta_base/fixed_function.hpp"
#include "meta_base/fnv1a_hash.hpp" #include "meta_base/fnv1a_hash.hpp"
@@ -24,7 +23,6 @@
#include "meta_base/memory_buffer.hpp" #include "meta_base/memory_buffer.hpp"
#include "meta_base/noncopyable.hpp" #include "meta_base/noncopyable.hpp"
#include "meta_base/nonesuch.hpp" #include "meta_base/nonesuch.hpp"
#include "meta_base/overloaded.hpp"
#include "meta_base/select_overload.hpp" #include "meta_base/select_overload.hpp"
#include "meta_base/to_underlying.hpp" #include "meta_base/to_underlying.hpp"
#include "meta_base/type_kinds.hpp" #include "meta_base/type_kinds.hpp"

156
headers/meta.hpp/meta_base/defer.hpp
View File

@@ -1,156 +0,0 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/meta.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2021-2023, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#pragma once
#include "base.hpp"
namespace meta_hpp::detail
{
namespace 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_{};
};
}
template < typename F, typename... Args >
class defer final : public impl::defer_impl<F, Args...> {
public:
defer() = delete;
defer(defer&&) = delete;
defer(const defer&) = delete;
defer& operator=(defer&&) = delete;
defer& operator=(const defer&) = delete;
template < typename UF >
explicit defer(UF&& f, std::tuple<Args...>&& args)
: impl::defer_impl<F, Args...>{std::forward<UF>(f), std::move(args)} {}
~defer() noexcept = default;
};
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();
}
}
private:
int exceptions_{};
};
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:
int exceptions_{};
};
template < typename F, typename... Args >
auto make_defer(F&& f, Args&&... 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)...)};
}
template < typename F, typename... Args >
auto make_error_defer(F&& f, Args&&... 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)...)};
}
template < typename F, typename... Args >
auto make_return_defer(F&& f, Args&&... 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)...)};
}
}
#ifdef __COUNTER__
# define META_HPP_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_defer_, __COUNTER__) { \
::meta_hpp::detail::make_defer(__VA_ARGS__) \
}
# define META_HPP_ERROR_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_error_defer_, __COUNTER__) { \
::meta_hpp::detail::make_error_defer(__VA_ARGS__) \
}
# define META_HPP_RETURN_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_return_defer_, __COUNTER__) { \
::meta_hpp::detail::make_return_defer(__VA_ARGS__) \
}
#else
# define META_HPP_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_defer_, __LINE__) { \
::meta_hpp::detail::make_defer(__VA_ARGS__) \
}
# define META_HPP_ERROR_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_error_defer_, __LINE__) { \
::meta_hpp::detail::make_error_defer(__VA_ARGS__) \
}
# define META_HPP_RETURN_DEFER(...) \
auto META_HPP_PP_CAT(meta_hpp_generated_return_defer_, __LINE__) { \
::meta_hpp::detail::make_return_defer(__VA_ARGS__) \
}
#endif

20
headers/meta.hpp/meta_base/overloaded.hpp
View File

@@ -1,20 +0,0 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/meta.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2021-2023, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#pragma once
#include "base.hpp"
namespace meta_hpp::detail
{
template < typename... Ts >
struct overloaded : Ts... {
using Ts::operator()...;
};
template < typename... Ts >
overloaded(Ts...) -> overloaded<Ts...>;
}