remove virtual dtors

.clang-tidy

@@ -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,
-        '
-...

.gitignore

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

.vscode/settings.json

@@ -1,29 +1,15 @@
 {
-    "[cpp]": {
+    "[c][cpp][json][jsonc][python][yaml]": {
-        "files.encoding": "utf8",
+        "editor.formatOnSave": true,
-        "files.insertFinalNewline": true,
-        "files.trimFinalNewlines": true,
-        "files.trimTrailingWhitespace": true
     },
-    "[cmake]": {
+    "[c][cmake][cpp][json][jsonc][markdown][python][yaml]": {
-        "files.encoding": "utf8",
-        "files.insertFinalNewline": true,
-        "files.trimFinalNewlines": true,
-        "files.trimTrailingWhitespace": true
-    },
-    "[python]": {
         "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"
 }

headers/.clang-format

@@ -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

headers/.clangd

@@ -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

headers/defer.hpp/defer.hpp

@@ -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;
+            base_defer_t() = delete;
-            defer_impl(defer_impl&&) = delete;
+            base_defer_t(base_defer_t&&) = delete;
-            defer_impl(const defer_impl&) = delete;
+            base_defer_t(const base_defer_t&) = delete;
-            defer_impl& operator=(defer_impl&&) = delete;
+            base_defer_t& operator=(base_defer_t&&) = delete;
-            defer_impl& operator=(const defer_impl&) = delete;
+            base_defer_t& operator=(const base_defer_t&) = delete;
 
             template < typename UF >
-            explicit defer_impl(
+            explicit base_defer_t(UF&& f, std::tuple<Args...>&& args)
-                UF&& f,
+            : f_{std::forward<UF>(f)}
-                std::tuple<Args...>&& args)
+            , args_{std::move(args)} {}
-            : f_(std::forward<UF>(f))
-            , args_(std::move(args)) {}
-
-            virtual ~defer_impl() noexcept {
-                if ( !dismissed_ ) {
-                    std::apply(std::move(f_), 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;
+            defer_t() = delete;
-            error_defer_impl(error_defer_impl&&) = delete;
+            defer_t(defer_t&&) = delete;
-            error_defer_impl(const error_defer_impl&) = delete;
+            defer_t(const defer_t&) = delete;
-            error_defer_impl& operator=(error_defer_impl&&) = delete;
+            defer_t& operator=(defer_t&&) = delete;
-            error_defer_impl& operator=(const error_defer_impl&) = delete;
+            defer_t& operator=(const defer_t&) = delete;
 
             template < typename UF >
-            explicit error_defer_impl(
+            explicit defer_t(UF&& f, std::tuple<Args...>&& args)
-                UF&& f,
+            : base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)} {}
-                std::tuple<Args...>&& args)
-            : defer_impl<F, Args...>(std::forward<UF>(f), std::move(args))
-            , exceptions_(std::uncaught_exceptions()) {}
 
-            ~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_t() = delete;
-            return_defer_impl(return_defer_impl&&) = delete;
+            return_defer_t(return_defer_t&&) = delete;
-            return_defer_impl(const return_defer_impl&) = delete;
+            return_defer_t(const return_defer_t&) = delete;
-            return_defer_impl& operator=(return_defer_impl&&) = delete;
+            return_defer_t& operator=(return_defer_t&&) = delete;
-            return_defer_impl& operator=(const return_defer_impl&) = delete;
+            return_defer_t& operator=(const return_defer_t&) = delete;
 
             template < typename UF >
-            explicit return_defer_impl(
+            explicit return_defer_t(UF&& f, std::tuple<Args...>&& args)
-                UF&& f,
+            : base_defer_t<F, Args...>{std::forward<UF>(f), std::move(args)}
-                std::tuple<Args...>&& args)
+            , exceptions_{std::uncaught_exceptions()} {}
-            : defer_impl<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<
+        using defer_t = impl::defer_t<std::decay_t<F>, std::decay_t<Args>...>;
-            std::decay_t<F>,
+        return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
-            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<
+        using defer_t = impl::error_defer_t<std::decay_t<F>, std::decay_t<Args>...>;
-            std::decay_t<F>,
+        return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
-            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<
+        using defer_t = impl::return_defer_t<std::decay_t<F>, std::decay_t<Args>...>;
-            std::decay_t<F>,
+        return defer_t{std::forward<F>(f), std::make_tuple(std::forward<Args>(args)...)};
-            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(...)\
+#    define DEFER_HPP(...) \
-        auto DEFER_HPP_IMPL_PP_CAT(generated_defer_, __COUNTER__) =\
+        auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __COUNTER__) { ::defer_hpp::make_defer(__VA_ARGS__) }
-            ::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 ERROR_DEFER_HPP(...)\
+#    define RETURN_DEFER_HPP(...) \
-        auto DEFER_HPP_IMPL_PP_CAT(generated_error_defer_, __COUNTER__) =\
+        auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __COUNTER__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
-            ::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__)
 #else
-    #define DEFER_HPP(...)\
+#    define DEFER_HPP(...) \
-        auto DEFER_HPP_IMPL_PP_CAT(generated_defer_, __LINE__) =\
+        auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_defer_, __LINE__) { ::defer_hpp::make_defer(__VA_ARGS__) }
-            ::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 ERROR_DEFER_HPP(...)\
+#    define RETURN_DEFER_HPP(...) \
-        auto DEFER_HPP_IMPL_PP_CAT(generated_error_defer_, __LINE__) =\
+        auto DEFER_HPP_IMPL_PP_CAT(defer_hpp_generated_return_defer_, __LINE__) { ::defer_hpp::make_return_defer(__VA_ARGS__) }
-            ::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__)
 #endif

untests/.clang-format

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

untests/.clang-tidy

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

untests/.clangd

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