experimental/status-code/std_error_code.hpp

0001 /* Proposed SG14 status_code
0002 (C) 2018 - 2021 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
0003 File Created: Aug 2018
0004
0005
0006 Licensed under the Apache License, Version 2.0 (the "License");
0007 you may not use this file except in compliance with the License.
0008 You may obtain a copy of the License in the accompanying file
0009 Licence.txt or at
0010
0011 http://www.apache.org/licenses/LICENSE-2.0
0012
0013 Unless required by applicable law or agreed to in writing, software
0014 distributed under the License is distributed on an "AS IS" BASIS,
0015 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0016 See the License for the specific language governing permissions and
0017 limitations under the License.
0018
0019
0020 Distributed under the Boost Software License, Version 1.0.
0021 (See accompanying file Licence.txt or copy at
0022 http://www.boost.org/LICENSE_1_0.txt)
0023 */
0024
0025 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_STD_ERROR_CODE_HPP
0026 #define BOOST_OUTCOME_SYSTEM_ERROR2_STD_ERROR_CODE_HPP
0027
0028 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NOT_POSIX
0029 #include "posix_code.hpp"
0030 #endif
0031
0032 #if defined(_WIN32) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE)
0033 #include "win32_code.hpp"
0034 #endif
0035
0036 #include <system_error>
0037
0038 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN
0039
0040 class _std_error_code_domain;
0041 //! A `status_code` representing exactly a `std::error_code`
0042 using std_error_code = status_code<_std_error_code_domain>;
0043
0044 namespace mixins
0045 {
0046   template <class Base> struct mixin<Base, _std_error_code_domain> : public Base
0047   {
0048     using Base::Base;
0049
0050     //! Implicit constructor from a `std::error_code`
0051     inline mixin(std::error_code ec);
0052
0053     //! Returns the error code category
0054     inline const std::error_category &category() const noexcept;
0055   };
0056 }  // namespace mixins
0057
0058
0059 /*! The implementation of the domain for `std::error_code` error codes.
0060  */
0061 class _std_error_code_domain final : public status_code_domain
0062 {
0063   template <class DomainType> friend class status_code;
0064   using _base = status_code_domain;
0065   using _error_code_type = std::error_code;
0066   using _error_category_type = std::error_category;
0067
0068   std::string _name;
0069
0070   static _base::string_ref _make_string_ref(_error_code_type c) noexcept
0071   {
0072 #if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
0073     try
0074 #endif
0075     {
0076       std::string msg = c.message();
0077       auto *p = static_cast<char *>(malloc(msg.size() + 1));  // NOLINT
0078       if(p == nullptr)
0079       {
0080         return _base::string_ref("failed to allocate message");
0081       }
0082       memcpy(p, msg.c_str(), msg.size() + 1);
0083       return _base::atomic_refcounted_string_ref(p, msg.size());
0084     }
0085 #if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
0086     catch(...)
0087     {
0088       return _base::string_ref("failed to allocate message");
0089     }
0090 #endif
0091   }
0092
0093 public:
0094   //! The value type of the `std::error_code` code, which stores the `int` from the `std::error_code`
0095   using value_type = int;
0096   using _base::string_ref;
0097
0098   //! Returns the error category singleton pointer this status code domain represents
0099   const _error_category_type &error_category() const noexcept
0100   {
0101     auto ptr = 0x223a160d20de97b4 ^ this->id();
0102     return *reinterpret_cast<const _error_category_type *>(ptr);
0103   }
0104
0105   //! Default constructor
0106   explicit _std_error_code_domain(const _error_category_type &category) noexcept
0107       : _base(0x223a160d20de97b4 ^ reinterpret_cast<_base::unique_id_type>(&category))
0108       , _name("std_error_code_domain(")
0109   {
0110     _name.append(category.name());
0111     _name.push_back(')');
0112   }
0113   _std_error_code_domain(const _std_error_code_domain &) = default;
0114   _std_error_code_domain(_std_error_code_domain &&) = default;
0115   _std_error_code_domain &operator=(const _std_error_code_domain &) = default;
0116   _std_error_code_domain &operator=(_std_error_code_domain &&) = default;
0117   ~_std_error_code_domain() = default;
0118
0119   static inline const _std_error_code_domain *get(_error_code_type ec);
0120
0121   virtual string_ref name() const noexcept override { return string_ref(_name.c_str(), _name.size()); }  // NOLINT
0122
0123   virtual payload_info_t payload_info() const noexcept override
0124   {
0125     return {sizeof(value_type), sizeof(status_code_domain *) + sizeof(value_type),
0126             (alignof(value_type) > alignof(status_code_domain *)) ? alignof(value_type) : alignof(status_code_domain *)};
0127   }
0128
0129 protected:
0130   virtual bool _do_failure(const status_code<void> &code) const noexcept override;
0131   virtual bool _do_equivalent(const status_code<void> &code1, const status_code<void> &code2) const noexcept override;
0132   virtual generic_code _generic_code(const status_code<void> &code) const noexcept override;
0133   virtual string_ref _do_message(const status_code<void> &code) const noexcept override;
0134 #if defined(_CPPUNWIND) || defined(__EXCEPTIONS) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE)
0135   BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN virtual void _do_throw_exception(const status_code<void> &code) const override;
0136 #endif
0137 };
0138
0139 namespace detail
0140 {
0141   extern inline _std_error_code_domain *std_error_code_domain_from_category(const std::error_category &category)
0142   {
0143     static constexpr size_t max_items = 64;
0144     static struct storage_t
0145     {
0146       std::atomic<unsigned> _lock;
0147       union item_t
0148       {
0149         int _init;
0150         _std_error_code_domain domain;
0151         constexpr item_t()
0152             : _init(0)
0153         {
0154         }
0155         ~item_t() {}
0156       } items[max_items];
0157       size_t count{0};
0158
0159       void lock()
0160       {
0161         while(_lock.exchange(1, std::memory_order_acquire) != 0)
0162           ;
0163       }
0164       void unlock() { _lock.store(0, std::memory_order_release); }
0165
0166       storage_t() {}
0167       ~storage_t()
0168       {
0169         lock();
0170         for(size_t n = 0; n < count; n++)
0171         {
0172           items[n].domain.~_std_error_code_domain();
0173         }
0174         unlock();
0175       }
0176       _std_error_code_domain *add(const std::error_category &category)
0177       {
0178         _std_error_code_domain *ret = nullptr;
0179         lock();
0180         for(size_t n = 0; n < count; n++)
0181         {
0182           if(items[n].domain.error_category() == category)
0183           {
0184             ret = &items[n].domain;
0185             break;
0186           }
0187         }
0188         if(ret == nullptr && count < max_items)
0189         {
0190           ret = new(std::addressof(items[count++].domain)) _std_error_code_domain(category);
0191         }
0192         unlock();
0193         return ret;
0194       }
0195     } storage;
0196     return storage.add(category);
0197   }
0198 }  // namespace detail
0199
0200 namespace mixins
0201 {
0202   template <class Base>
0203   inline mixin<Base, _std_error_code_domain>::mixin(std::error_code ec)
0204       : Base(typename Base::_value_type_constructor{}, _std_error_code_domain::get(ec), ec.value())
0205   {
0206   }
0207
0208   template <class Base> inline const std::error_category &mixin<Base, _std_error_code_domain>::category() const noexcept
0209   {
0210     const auto &domain = static_cast<const _std_error_code_domain &>(this->domain());
0211     return domain.error_category();
0212   };
0213 }  // namespace mixins
0214
0215 inline const _std_error_code_domain *_std_error_code_domain::get(std::error_code ec)
0216 {
0217   auto *p = detail::std_error_code_domain_from_category(ec.category());
0218   assert(p != nullptr);
0219   if(p == nullptr)
0220   {
0221     abort();
0222   }
0223   return p;
0224 }
0225
0226
0227 inline bool _std_error_code_domain::_do_failure(const status_code<void> &code) const noexcept
0228 {
0229   assert(code.domain() == *this);
0230   return static_cast<const std_error_code &>(code).value() != 0;  // NOLINT
0231 }
0232
0233 inline bool _std_error_code_domain::_do_equivalent(const status_code<void> &code1, const status_code<void> &code2) const noexcept
0234 {
0235   assert(code1.domain() == *this);
0236   const auto &c1 = static_cast<const std_error_code &>(code1);  // NOLINT
0237   const auto &cat1 = c1.category();
0238   // Are we comparing to another wrapped error_code?
0239   if(code2.domain() == *this)
0240   {
0241     const auto &c2 = static_cast<const std_error_code &>(code2);  // NOLINT
0242     const auto &cat2 = c2.category();
0243     // If the error code categories are identical, do literal comparison
0244     if(cat1 == cat2)
0245     {
0246       return c1.value() == c2.value();
0247     }
0248     // Otherwise fall back onto the _generic_code comparison, which uses default_error_condition()
0249     return false;
0250   }
0251   // Am I an error code with generic category?
0252   if(cat1 == std::generic_category())
0253   {
0254     // Convert to generic code, and compare that
0255     generic_code _c1(static_cast<errc>(c1.value()));
0256     return _c1 == code2;
0257   }
0258   // Am I an error code with system category?
0259   if(cat1 == std::system_category())
0260   {
0261 // Convert to POSIX or Win32 code, and compare that
0262 #ifdef _WIN32
0263     win32_code _c1((win32::DWORD) c1.value());
0264     return _c1 == code2;
0265 #elif !defined(BOOST_OUTCOME_SYSTEM_ERROR2_NOT_POSIX)
0266     posix_code _c1(c1.value());
0267     return _c1 == code2;
0268 #endif
0269   }
0270   return false;
0271 }
0272
0273 inline generic_code _std_error_code_domain::_generic_code(const status_code<void> &code) const noexcept
0274 {
0275   assert(code.domain() == *this);
0276   const auto &c = static_cast<const std_error_code &>(code);  // NOLINT
0277   // Ask my embedded error code for its mapping to std::errc, which is a subset of our generic_code errc.
0278   std::error_condition cond(c.category().default_error_condition(c.value()));
0279   if(cond.category() == std::generic_category())
0280   {
0281     return generic_code(static_cast<errc>(cond.value()));
0282   }
0283 #if !defined(BOOST_OUTCOME_SYSTEM_ERROR2_NOT_POSIX) && !defined(_WIN32)
0284   if(cond.category() == std::system_category())
0285   {
0286     return generic_code(static_cast<errc>(cond.value()));
0287   }
0288 #endif
0289   return errc::unknown;
0290 }
0291
0292 inline _std_error_code_domain::string_ref _std_error_code_domain::_do_message(const status_code<void> &code) const noexcept
0293 {
0294   assert(code.domain() == *this);
0295   const auto &c = static_cast<const std_error_code &>(code);  // NOLINT
0296   return _make_string_ref(_error_code_type(c.value(), c.category()));
0297 }
0298
0299 #if defined(_CPPUNWIND) || defined(__EXCEPTIONS) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE)
0300 BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN inline void _std_error_code_domain::_do_throw_exception(const status_code<void> &code) const
0301 {
0302   assert(code.domain() == *this);
0303   const auto &c = static_cast<const std_error_code &>(code);  // NOLINT
0304   throw std::system_error(std::error_code(c.value(), c.category()));
0305 }
0306 #endif
0307
0308 static_assert(sizeof(std_error_code) <= sizeof(void *) * 2, "std_error_code does not fit into a system_code!");
0309
0310 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END
0311
0312 // Enable implicit construction of `std_error_code` from `std::error_code`.
0313 namespace std
0314 {
0315   inline BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::std_error_code make_status_code(error_code c) noexcept
0316   {
0317     return BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::std_error_code(c);
0318   }
0319 }  // namespace std
0320
0321 #endif