feat():initial version

install/boost_1_75_0/include/boost/leaf/capture.hpp

@@ -0,0 +1,300 @@
+#ifndef BOOST_LEAF_CAPTURE_HPP_INCLUDED
+#define BOOST_LEAF_CAPTURE_HPP_INCLUDED
+
+// Copyright (c) 2018-2020 Emil Dotchevski and Reverge Studios, Inc.
+
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_LEAF_ENABLE_WARNINGS
+#   if defined(__clang__)
+#       pragma clang system_header
+#   elif (__GNUC__*100+__GNUC_MINOR__>301)
+#       pragma GCC system_header
+#   elif defined(_MSC_VER)
+#       pragma warning(push,1)
+#   endif
+#endif
+
+#include <boost/leaf/exception.hpp>
+#include <boost/leaf/on_error.hpp>
+
+namespace boost { namespace leaf {
+
+    namespace leaf_detail
+    {
+        template <class R, bool IsResult = is_result_type<R>::value>
+        struct is_result_tag;
+
+        template <class R>
+        struct is_result_tag<R, false>
+        {
+        };
+
+        template <class R>
+        struct is_result_tag<R, true>
+        {
+        };
+    }
+
+#ifdef BOOST_LEAF_NO_EXCEPTIONS
+
+    namespace leaf_detail
+    {
+        template <class R, class F, class... A>
+        inline
+        decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
+        capture_impl(is_result_tag<R, false>, context_ptr && ctx, F && f, A... a) noexcept
+        {
+            auto active_context = activate_context(*ctx);
+            return std::forward<F>(f)(std::forward<A>(a)...);
+        }
+
+        template <class R, class F, class... A>
+        inline
+        decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
+        capture_impl(is_result_tag<R, true>, context_ptr && ctx, F && f, A... a) noexcept
+        {
+            auto active_context = activate_context(*ctx);
+            if( auto r = std::forward<F>(f)(std::forward<A>(a)...) )
+                return r;
+            else
+            {
+                ctx->captured_id_ = r.error();
+                return std::move(ctx);
+            }
+        }
+
+        template <class R, class Future>
+        inline
+        decltype(std::declval<Future>().get())
+        future_get_impl(is_result_tag<R, false>, Future & fut) noexcept
+        {
+            return fut.get();
+        }
+
+        template <class R, class Future>
+        inline
+        decltype(std::declval<Future>().get())
+        future_get_impl(is_result_tag<R, true>, Future & fut) noexcept
+        {
+            if( auto r = fut.get() )
+                return r;
+            else
+                return error_id(r.error()); // unloads
+        }
+    }
+
+#else
+
+    namespace leaf_detail
+    {
+        class capturing_exception:
+            public std::exception
+        {
+            std::exception_ptr ex_;
+            context_ptr ctx_;
+
+        public:
+
+            capturing_exception(std::exception_ptr && ex, context_ptr && ctx) noexcept:
+                ex_(std::move(ex)),
+                ctx_(std::move(ctx))
+            {
+                BOOST_LEAF_ASSERT(ex_);
+                BOOST_LEAF_ASSERT(ctx_);
+                BOOST_LEAF_ASSERT(ctx_->captured_id_);
+            }
+
+            [[noreturn]] void unload_and_rethrow_original_exception() const
+            {
+                BOOST_LEAF_ASSERT(ctx_->captured_id_);
+                auto active_context = activate_context(*ctx_);
+                id_factory<>::current_id = ctx_->captured_id_.value();
+                std::rethrow_exception(ex_);
+            }
+
+            template <class CharT, class Traits>
+            void print( std::basic_ostream<CharT, Traits> & os ) const
+            {
+                ctx_->print(os);
+            }
+        };
+
+        template <class R, class F, class... A>
+        inline
+        decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
+        capture_impl(is_result_tag<R, false>, context_ptr && ctx, F && f, A... a)
+        {
+            auto active_context = activate_context(*ctx);
+            error_monitor cur_err;
+            try
+            {
+                return std::forward<F>(f)(std::forward<A>(a)...);
+            }
+            catch( capturing_exception const & )
+            {
+                throw;
+            }
+            catch( exception_base const & e )
+            {
+                ctx->captured_id_ = e.get_error_id();
+                throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            }
+            catch(...)
+            {
+                ctx->captured_id_ = cur_err.assigned_error_id();
+                throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            }
+        }
+
+        template <class R, class F, class... A>
+        inline
+        decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
+        capture_impl(is_result_tag<R, true>, context_ptr && ctx, F && f, A... a)
+        {
+            auto active_context = activate_context(*ctx);
+            error_monitor cur_err;
+            try
+            {
+                if( auto && r = std::forward<F>(f)(std::forward<A>(a)...) )
+                    return std::move(r);
+                else
+                {
+                    ctx->captured_id_ = r.error();
+                    return std::move(ctx);
+                }
+            }
+            catch( capturing_exception const & )
+            {
+                throw;
+            }
+            catch( exception_base const & e )
+            {
+                ctx->captured_id_ = e.get_error_id();
+                throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            }
+            catch(...)
+            {
+                ctx->captured_id_ = cur_err.assigned_error_id();
+                throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            }
+        }
+
+        template <class R, class Future>
+        inline
+        decltype(std::declval<Future>().get())
+        future_get_impl(is_result_tag<R, false>, Future & fut )
+        {
+            try
+            {
+                return fut.get();
+            }
+            catch( capturing_exception const & cap )
+            {
+                cap.unload_and_rethrow_original_exception();
+            }
+        }
+
+        template <class R, class Future>
+        inline
+        decltype(std::declval<Future>().get())
+        future_get_impl(is_result_tag<R, true>, Future & fut )
+        {
+            try
+            {
+                if( auto r = fut.get() )
+                    return r;
+                else
+                    return error_id(r.error()); // unloads
+            }
+            catch( capturing_exception const & cap )
+            {
+                cap.unload_and_rethrow_original_exception();
+            }
+        }
+    }
+
+#endif
+
+    template <class F, class... A>
+    inline
+    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
+    capture(context_ptr && ctx, F && f, A... a)
+    {
+        using namespace leaf_detail;
+        return capture_impl(is_result_tag<decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))>(), std::move(ctx), std::forward<F>(f), std::forward<A>(a)...);
+    }
+
+    template <class Future>
+    inline
+    decltype(std::declval<Future>().get())
+    future_get( Future & fut )
+    {
+        using namespace leaf_detail;
+        return future_get_impl(is_result_tag<decltype(std::declval<Future>().get())>(), fut);
+    }
+
+    ////////////////////////////////////////
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+    template <class T>
+    class result;
+
+    namespace leaf_detail
+    {
+        inline error_id catch_exceptions_helper( std::exception const & ex, leaf_detail_mp11::mp_list<> )
+        {
+            return leaf::new_error(std::current_exception());
+        }
+
+        template <class Ex1, class... Ex>
+        inline error_id catch_exceptions_helper( std::exception const & ex, leaf_detail_mp11::mp_list<Ex1,Ex...> )
+        {
+            if( Ex1 const * p = dynamic_cast<Ex1 const *>(&ex) )
+                return catch_exceptions_helper(ex, leaf_detail_mp11::mp_list<Ex...>{ }).load(*p);
+            else
+                return catch_exceptions_helper(ex, leaf_detail_mp11::mp_list<Ex...>{ });
+        }
+
+        template <class T>
+        struct deduce_exception_to_result_return_type_impl
+        {
+            using type = result<T>;
+        };
+
+        template <class T>
+        struct deduce_exception_to_result_return_type_impl<result<T>>
+        {
+            using type = result<T>;
+        };
+
+        template <class T>
+        using deduce_exception_to_result_return_type = typename deduce_exception_to_result_return_type_impl<T>::type;
+    }
+
+    template <class... Ex, class F>
+    inline
+    leaf_detail::deduce_exception_to_result_return_type<leaf_detail::fn_return_type<F>>
+    exception_to_result( F && f ) noexcept
+    {
+        try
+        {
+            return std::forward<F>(f)();
+        }
+        catch( std::exception const & ex )
+        {
+            return leaf_detail::catch_exceptions_helper(ex, leaf_detail_mp11::mp_list<Ex...>());
+        }
+        catch(...)
+        {
+            return leaf::new_error(std::current_exception());
+        }
+    }
+
+#endif
+
+} }
+
+#endif