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

remove virtual dtors

Browse Source
This commit is contained in:
BlackMATov
2023-03-01 16:20:26 +07:00
parent 6324945be2
commit 57d0033c6b
9 changed files with 155 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
.clang-tidy
View File

@@ -1,23 +0,0 @@
---
Checks: '-*,
bugprone-*,
clang-analyzer-*,
concurrency-*,
cppcoreguidelines-*,
-cppcoreguidelines-macro-usage,
modernize-*,
-modernize-use-trailing-return-type,
performance-*,
portability-*,
readability-*,
-readability-identifier-length,
'
...

8
.gitignore vendored
View File

@@ -1,4 +1,4 @@
build/*
install/*
.clangd/*
CMakeLists.txt.user
.DS_Store
/.cdb/*
/build/*
/install/*

22
.vscode/settings.json vendored
View File

@@ -1,29 +1,15 @@
{
"[cpp]": {
"files.encoding": "utf8",
"files.insertFinalNewline": true,
"files.trimFinalNewlines": true,
"files.trimTrailingWhitespace": true
"[c][cpp][json][jsonc][python][yaml]": {
"editor.formatOnSave": true,
},
"[cmake]": {
"files.encoding": "utf8",
"files.insertFinalNewline": true,
"files.trimFinalNewlines": true,
"files.trimTrailingWhitespace": true
},
"[python]": {
"[c][cmake][cpp][json][jsonc][markdown][python][yaml]": {
"files.encoding": "utf8",
"files.insertFinalNewline": true,
"files.trimFinalNewlines": true,
"files.trimTrailingWhitespace": true
},
"clangd.arguments": [
"--all-scopes-completion",
"--background-index",
"--clang-tidy",
"--compile-commands-dir=${workspaceFolder}/.clangd",
"--completion-style=detailed",
"--header-insertion=never"
],
"cmake.copyCompileCommands": "${workspaceFolder}/.clangd/compile_commands.json"
"cmake.copyCompileCommands": "${workspaceFolder}/.cdb/compile_commands.json"
}

33
headers/.clang-format Normal file
View File

@@ -0,0 +1,33 @@
Language: Cpp
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: BlockIndent
AlignEscapedNewlines: DontAlign
AlignOperands: AlignAfterOperator
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortFunctionsOnASingleLine: Empty
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false
BinPackParameters: false
BraceWrapping: { AfterNamespace: true }
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
BreakConstructorInitializers: BeforeComma
BreakInheritanceList: BeforeComma
ColumnLimit: 130
ConstructorInitializerIndentWidth: 0
FixNamespaceComments: false
IndentPPDirectives: AfterHash
IndentWidth: 4
LambdaBodyIndentation: OuterScope
NamespaceIndentation: All
PackConstructorInitializers: Never
PenaltyBreakAssignment: 100
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
PPIndentWidth: 4
SeparateDefinitionBlocks: Always
SpacesInAngles: Leave
SpacesInConditionalStatement: true

29
headers/.clangd Normal file
View File

@@ -0,0 +1,29 @@
Diagnostics:
ClangTidy:
Add:
- bugprone-*
- clang-analyzer-*
- concurrency-*
- cppcoreguidelines-*
- misc-*
- modernize-*
- performance-*
- portability-*
- readability-*
Remove:
- bugprone-easily-swappable-parameters
- bugprone-macro-parentheses
- cppcoreguidelines-macro-usage
- cppcoreguidelines-non-private-member-variables-in-classes
- misc-no-recursion
- misc-non-private-member-variables-in-classes
- misc-unused-using-decls
- modernize-use-trailing-return-type
- readability-identifier-length
- readability-named-parameter
- readability-redundant-access-specifiers
- readability-simplify-boolean-expr
- readability-use-anyofallof
CompileFlags:
CompilationDatabase: ../.cdb

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

@@ -16,54 +16,70 @@ namespace defer_hpp
namespace impl
{
template < typename F, typename... Args >
class defer_impl {
class base_defer_t {
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;
base_defer_t() = delete;
base_defer_t(base_defer_t&&) = delete;
base_defer_t(const base_defer_t&) = delete;
base_defer_t& operator=(base_defer_t&&) = delete;
base_defer_t& operator=(const base_defer_t&) = delete;
template < typename UF >
explicit defer_impl(
UF&& f,
std::tuple<Args...>&& args)
: f_(std::forward<UF>(f))
, args_(std::move(args)) {}
virtual ~defer_impl() noexcept {
if ( !dismissed_ ) {
std::apply(std::move(f_), std::move(args_));
}
}
explicit base_defer_t(UF&& f, std::tuple<Args...>&& args)
: f_{std::forward<UF>(f)}
, args_{std::move(args)} {}
void dismiss() noexcept {
dismissed_ = true;
}
protected:
~base_defer_t() noexcept {
if ( !dismissed_ ) {
std::apply(std::move(f_), std::move(args_));
}
}
private:
F f_;
std::tuple<Args...> args_;
bool dismissed_{};
};
}
namespace impl
{
template < typename F, typename... Args >
class error_defer_impl final : public defer_impl<F, Args...> {
class defer_t final : public base_defer_t<F, Args...> {
public:
error_defer_impl() = delete;
error_defer_impl(error_defer_impl&&) = delete;
error_defer_impl(const error_defer_impl&) = delete;
error_defer_impl& operator=(error_defer_impl&&) = delete;
error_defer_impl& operator=(const error_defer_impl&) = delete;
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 error_defer_impl(
UF&& f,
std::tuple<Args...>&& args)
: defer_impl<F, Args...>(std::forward<UF>(f), std::move(args))
, exceptions_(std::uncaught_exceptions()) {}
explicit defer_t(UF&& f, std::tuple<Args...>&& args)
: base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)} {}
~error_defer_impl() noexcept final {
~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();
}
@@ -74,22 +90,20 @@ namespace defer_hpp
};
template < typename F, typename... Args >
class return_defer_impl final : public defer_impl<F, Args...> {
class return_defer_t final : public base_defer_t<F, Args...> {
public:
return_defer_impl() = delete;
return_defer_impl(return_defer_impl&&) = delete;
return_defer_impl(const return_defer_impl&) = delete;
return_defer_impl& operator=(return_defer_impl&&) = delete;
return_defer_impl& operator=(const return_defer_impl&) = delete;
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_impl(
UF&& f,
std::tuple<Args...>&& args)
: defer_impl<F, Args...>(std::forward<UF>(f), std::move(args))
, exceptions_(std::uncaught_exceptions()) {}
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_impl() noexcept final {
~return_defer_t() noexcept {
if ( exceptions_ != std::uncaught_exceptions() ) {
this->dismiss();
}
@@ -102,60 +116,38 @@ namespace defer_hpp
template < typename F, typename... Args >
auto make_defer(F&& f, Args&&... args) {
using defer_t = impl::defer_impl<
std::decay_t<F>,
std::decay_t<Args>...>;
return defer_t(
std::forward<F>(f),
std::make_tuple(std::forward<Args>(args)...));
using defer_t = impl::defer_t<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 = impl::error_defer_impl<
std::decay_t<F>,
std::decay_t<Args>...>;
return defer_t(
std::forward<F>(f),
std::make_tuple(std::forward<Args>(args)...));
using defer_t = impl::error_defer_t<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 = impl::return_defer_impl<
std::decay_t<F>,
std::decay_t<Args>...>;
return defer_t(
std::forward<F>(f),
std::make_tuple(std::forward<Args>(args)...));
using defer_t = impl::return_defer_t<std::decay_t<F>, std::decay_t<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_IMPL_PP_CAT_I(x, y) x ## y
#define DEFER_HPP_IMPL_PP_CAT_I(x, y) x##y
#ifdef __COUNTER__
#define DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_defer_, __COUNTER__) =\
::defer_hpp::make_defer(__VA_ARGS__)
#define ERROR_DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_error_defer_, __COUNTER__) =\
::defer_hpp::make_error_defer(__VA_ARGS__)
#define RETURN_DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_return_defer_, __COUNTER__) =\
::defer_hpp::make_return_defer(__VA_ARGS__)
# define DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __COUNTER__) { ::defer_hpp::make_defer(__VA_ARGS__) }
# define ERROR_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_error_defer_, __COUNTER__) { ::defer_hpp::make_error_defer(__VA_ARGS__) }
# define RETURN_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __COUNTER__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
#else
#define DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_defer_, __LINE__) =\
::defer_hpp::make_defer(__VA_ARGS__)
#define ERROR_DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_error_defer_, __LINE__) =\
::defer_hpp::make_error_defer(__VA_ARGS__)
#define RETURN_DEFER_HPP(...)\
auto DEFER_HPP_IMPL_PP_CAT(generated_return_defer_, __LINE__) =\
::defer_hpp::make_return_defer(__VA_ARGS__)
# define DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __LINE__) { ::defer_hpp::make_defer(__VA_ARGS__) }
# define ERROR_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_error_defer_, __LINE__) { ::defer_hpp::make_error_defer(__VA_ARGS__) }
# define RETURN_DEFER_HPP(...) \
auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __LINE__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
#endif

1
untests/.clang-format Normal file
View File

@@ -0,0 +1 @@
DisableFormat: true

18
untests/.clang-tidy
View File

@@ -1,18 +0,0 @@
---
Checks: '-*,
bugprone-*,
clang-analyzer-*,
concurrency-*,
modernize-*,
-modernize-avoid-c-arrays,
-modernize-use-trailing-return-type,
performance-*,
portability-*,
'
...

10
untests/.clangd Normal file
View File

@@ -0,0 +1,10 @@
Diagnostics:
ClangTidy:
Remove:
- cppcoreguidelines-*
- modernize-*
- performance-*
- readability-*
CompileFlags:
CompilationDatabase: ../.cdb