--- /dev/null
+#ifndef BOOST_LEAF_RESULT_HPP_INCLUDED
+#define BOOST_LEAF_RESULT_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/error.hpp>
+#include <climits>
+
+namespace boost { namespace leaf {
+
+ class bad_result:
+ public std::exception,
+ public error_id
+ {
+ char const * what() const noexcept final override
+ {
+ return "boost::leaf::bad_result";
+ }
+
+ public:
+
+ explicit bad_result( error_id id ) noexcept:
+ error_id(id)
+ {
+ BOOST_LEAF_ASSERT(value());
+ }
+ };
+
+ ////////////////////////////////////////
+
+ namespace leaf_detail
+ {
+ template <class T>
+ struct stored
+ {
+ using type = T;
+ using value_type = T;
+ using value_type_const = T const;
+ using value_cref = T const &;
+ using value_ref = T &;
+ using value_rv_cref = T const &&;
+ using value_rv_ref = T &&;
+ };
+
+ template <class T>
+ struct stored<T &>
+ {
+ using type = std::reference_wrapper<T>;
+ using value_type_const = T;
+ using value_type = T;
+ using value_ref = T &;
+ using value_cref = T &;
+ using value_rv_ref = T &;
+ using value_rv_cref = T &;
+ };
+
+ class result_discriminant
+ {
+ unsigned state_;
+
+ public:
+
+ enum kind_t
+ {
+ no_error = 0,
+ err_id = 1,
+ ctx_ptr = 2,
+ val = 3
+ };
+
+ explicit result_discriminant( error_id id ) noexcept:
+ state_(id.value())
+ {
+ BOOST_LEAF_ASSERT(state_==0 || (state_&3)==1);
+ }
+
+ struct kind_val { };
+ explicit result_discriminant( kind_val ) noexcept:
+ state_(val)
+ {
+ }
+
+ struct kind_ctx_ptr { };
+ explicit result_discriminant( kind_ctx_ptr ) noexcept:
+ state_(ctx_ptr)
+ {
+ }
+
+ kind_t kind() const noexcept
+ {
+ return kind_t(state_&3);
+ }
+
+ error_id get_error_id() const noexcept
+ {
+ BOOST_LEAF_ASSERT(kind()==no_error || kind()==err_id);
+ return make_error_id(state_);
+ }
+ };
+ }
+
+ ////////////////////////////////////////
+
+ template <class T>
+ class result
+ {
+ template <class U>
+ friend class result;
+
+ using result_discriminant = leaf_detail::result_discriminant;
+
+ struct error_result
+ {
+ error_result( error_result && ) = default;
+ error_result( error_result const & ) = delete;
+ error_result & operator=( error_result const & ) = delete;
+
+ result & r_;
+
+ error_result( result & r ) noexcept:
+ r_(r)
+ {
+ }
+
+ template <class U>
+ operator result<U>() noexcept
+ {
+ switch(r_.what_.kind())
+ {
+ case result_discriminant::val:
+ return result<U>(error_id());
+ case result_discriminant::ctx_ptr:
+ return result<U>(std::move(r_.ctx_));
+ default:
+ return result<U>(std::move(r_.what_));
+ }
+ }
+
+ operator error_id() noexcept
+ {
+ switch(r_.what_.kind())
+ {
+ case result_discriminant::val:
+ return error_id();
+ case result_discriminant::ctx_ptr:
+ {
+ error_id captured_id = r_.ctx_->propagate_captured_errors();
+ leaf_detail::id_factory<>::current_id = captured_id.value();
+ return captured_id;
+ }
+ default:
+ return r_.what_.get_error_id();
+ }
+ }
+ };
+
+ using stored_type = typename leaf_detail::stored<T>::type;
+ using value_type = typename leaf_detail::stored<T>::value_type;
+ using value_type_const = typename leaf_detail::stored<T>::value_type_const;
+ using value_ref = typename leaf_detail::stored<T>::value_ref;
+ using value_cref = typename leaf_detail::stored<T>::value_cref;
+ using value_rv_ref = typename leaf_detail::stored<T>::value_rv_ref;
+ using value_rv_cref = typename leaf_detail::stored<T>::value_rv_cref;
+
+ union
+ {
+ stored_type stored_;
+ context_ptr ctx_;
+ };
+
+ result_discriminant what_;
+
+ void destroy() const noexcept
+ {
+ switch(this->what_.kind())
+ {
+ case result_discriminant::val:
+ stored_.~stored_type();
+ break;
+ case result_discriminant::ctx_ptr:
+ BOOST_LEAF_ASSERT(!ctx_ || ctx_->captured_id_);
+ ctx_.~context_ptr();
+ default:
+ break;
+ }
+ }
+
+ template <class U>
+ result_discriminant move_from( result<U> && x ) noexcept
+ {
+ auto x_what = x.what_;
+ switch(x_what.kind())
+ {
+ case result_discriminant::val:
+ (void) new(&stored_) stored_type(std::move(x.stored_));
+ break;
+ case result_discriminant::ctx_ptr:
+ BOOST_LEAF_ASSERT(!x.ctx_ || x.ctx_->captured_id_);
+ (void) new(&ctx_) context_ptr(std::move(x.ctx_));
+ default:
+ break;
+ }
+ return x_what;
+ }
+
+ result( result_discriminant && what ) noexcept:
+ what_(std::move(what))
+ {
+ BOOST_LEAF_ASSERT(what_.kind()==result_discriminant::err_id || what_.kind()==result_discriminant::no_error);
+ }
+
+ error_id get_error_id() const noexcept
+ {
+ BOOST_LEAF_ASSERT(what_.kind()!=result_discriminant::val);
+ return what_.kind()==result_discriminant::ctx_ptr ? ctx_->captured_id_ : what_.get_error_id();
+ }
+
+ static int init_T_with_U( T && );
+
+ protected:
+
+ void enforce_value_state() const
+ {
+ if( what_.kind() != result_discriminant::val )
+ ::boost::leaf::throw_exception(bad_result(get_error_id()));
+ }
+
+ public:
+
+ result( result && x ) noexcept:
+ what_(move_from(std::move(x)))
+ {
+ }
+
+ template <class U>
+ result( result<U> && x ) noexcept:
+ what_(move_from(std::move(x)))
+
+ {
+ }
+
+ result():
+ stored_(stored_type()),
+ what_(result_discriminant::kind_val{})
+ {
+ }
+
+ result( value_type && v ) noexcept:
+ stored_(std::forward<value_type>(v)),
+ what_(result_discriminant::kind_val{})
+ {
+ }
+
+ result( value_type const & v ):
+ stored_(v),
+ what_(result_discriminant::kind_val{})
+ {
+ }
+
+ result( error_id err ) noexcept:
+ what_(err)
+ {
+ }
+
+ // SFINAE: T can be initialized with a U, e.g. result<std::string>("literal").
+ // Not using is_constructible on purpose, bug with COMPILER=/usr/bin/clang++ CXXSTD=11 clang 3.3.
+ template <class U>
+ result( U && u, decltype(init_T_with_U(std::forward<U>(u))) * = 0 ):
+ stored_(std::forward<U>(u)),
+ what_(result_discriminant::kind_val{})
+ {
+ }
+
+ result( std::error_code const & ec ) noexcept:
+ what_(error_id(ec))
+ {
+ }
+
+ template <class Enum>
+ result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type * = 0 ) noexcept:
+ what_(error_id(e))
+ {
+ }
+
+ result( context_ptr && ctx ) noexcept:
+ ctx_(std::move(ctx)),
+ what_(result_discriminant::kind_ctx_ptr{})
+ {
+ }
+
+ ~result() noexcept
+ {
+ destroy();
+ }
+
+ result & operator=( result && x ) noexcept
+ {
+ destroy();
+ what_ = move_from(std::move(x));
+ return *this;
+ }
+
+ template <class U>
+ result & operator=( result<U> && x ) noexcept
+ {
+ destroy();
+ what_ = move_from(std::move(x));
+ return *this;
+ }
+
+ explicit operator bool() const noexcept
+ {
+ return what_.kind() == result_discriminant::val;
+ }
+
+ value_cref value() const &
+ {
+ enforce_value_state();
+ return stored_;
+ }
+
+ value_ref value() &
+ {
+ enforce_value_state();
+ return stored_;
+ }
+
+ value_rv_cref value() const &&
+ {
+ enforce_value_state();
+ return std::move(stored_);
+ }
+
+ value_rv_ref value() &&
+ {
+ enforce_value_state();
+ return std::move(stored_);
+ }
+
+ value_cref operator*() const &
+ {
+ return value();
+ }
+
+ value_ref operator*() &
+ {
+ return value();
+ }
+
+ value_rv_cref operator*() const &&
+ {
+ return value();
+ }
+
+ value_rv_ref operator*() &&
+ {
+ return value();
+ }
+
+ value_type_const * operator->() const
+ {
+ return &value();
+ }
+
+ value_type * operator->()
+ {
+ return &value();
+ }
+
+ error_result error() noexcept
+ {
+ return error_result{*this};
+ }
+
+ template <class... Item>
+ error_id load( Item && ... item ) noexcept
+ {
+ return error_id(error()).load(std::forward<Item>(item)...);
+ }
+ };
+
+ ////////////////////////////////////////
+
+ namespace leaf_detail
+ {
+ struct void_ { };
+ }
+
+ template <>
+ class result<void>:
+ result<leaf_detail::void_>
+ {
+ using result_discriminant = leaf_detail::result_discriminant;
+ using void_ = leaf_detail::void_;
+ using base = result<void_>;
+
+ template <class U>
+ friend class result;
+
+ result( result_discriminant && what ) noexcept:
+ base(std::move(what))
+ {
+ }
+
+ public:
+
+ using value_type = void;
+
+ result( result && x ) noexcept:
+ base(std::move(x))
+ {
+ }
+
+ result() noexcept
+ {
+ }
+
+ result( error_id err ) noexcept:
+ base(err)
+ {
+ }
+
+ result( std::error_code const & ec ) noexcept:
+ base(ec)
+ {
+ }
+
+ template <class Enum>
+ result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept:
+ base(e)
+ {
+ }
+
+ result( context_ptr && ctx ) noexcept:
+ base(std::move(ctx))
+ {
+ }
+
+ ~result() noexcept
+ {
+ }
+
+ void value() const
+ {
+ base::enforce_value_state();
+ }
+
+ using base::operator=;
+ using base::operator bool;
+ using base::get_error_id;
+ using base::error;
+ using base::load;
+ };
+
+ ////////////////////////////////////////
+
+ template <class R>
+ struct is_result_type;
+
+ template <class T>
+ struct is_result_type<result<T>>: std::true_type
+ {
+ };
+
+} }
+
+#endif
projects / ceph.git / blobdiff