experimental/status-code/errored_status_code.hpp

0001 /* Proposed SG14 status_code
0002 (C) 2018-2024 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
0003 File Created: Jun 2018
0004
0005
0006 Boost Software License - Version 1.0 - August 17th, 2003
0007
0008 Permission is hereby granted, free of charge, to any person or organization
0009 obtaining a copy of the software and accompanying documentation covered by
0010 this license (the "Software") to use, reproduce, display, distribute,
0011 execute, and transmit the Software, and to prepare derivative works of the
0012 Software, and to permit third-parties to whom the Software is furnished to
0013 do so, all subject to the following:
0014
0015 The copyright notices in the Software and this entire statement, including
0016 the above license grant, this restriction and the following disclaimer,
0017 must be included in all copies of the Software, in whole or in part, and
0018 all derivative works of the Software, unless such copies or derivative
0019 works are solely in the form of machine-executable object code generated by
0020 a source language processor.
0021
0022 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0023 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0024 FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
0025 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
0026 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
0027 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
0028 DEALINGS IN THE SOFTWARE.
0029 */
0030
0031 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_ERRORED_STATUS_CODE_HPP
0032 #define BOOST_OUTCOME_SYSTEM_ERROR2_ERRORED_STATUS_CODE_HPP
0033
0034 #include "quick_status_code_from_enum.hpp"
0035
0036 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN
0037
0038 /*! A `status_code` which is always a failure. The closest equivalent to
0039 `std::error_code`, except it cannot be modified, and is templated.
0040
0041 Differences from `status_code`:
0042
0043 - Never successful (this contract is checked on construction, if fails then it
0044 terminates the process).
0045 - Is immutable.
0046 */
0047 template <class DomainType> class errored_status_code : public status_code<DomainType>
0048 {
0049   using _base = status_code<DomainType>;
0050   using _base::clear;
0051   using _base::success;
0052
0053   void _check()
0054   {
0055     if(_base::success())
0056     {
0057       std::terminate();
0058     }
0059   }
0060
0061 public:
0062   //! The type of the domain.
0063   using typename _base::domain_type;
0064   //! The type of the error code.
0065   using typename _base::value_type;
0066   //! The type of a reference to a message string.
0067   using typename _base::string_ref;
0068
0069   //! Default constructor.
0070   errored_status_code() = default;
0071   //! Copy constructor.
0072   errored_status_code(const errored_status_code &) = default;
0073   //! Move constructor.
0074   errored_status_code(errored_status_code &&) = default;  // NOLINT
0075   //! Copy assignment.
0076   errored_status_code &operator=(const errored_status_code &) = default;
0077   //! Move assignment.
0078   errored_status_code &operator=(errored_status_code &&) = default;  // NOLINT
0079   ~errored_status_code() = default;
0080
0081   //! Explicitly construct from any similarly erased status code
0082   explicit errored_status_code(const _base &o) noexcept(std::is_nothrow_copy_constructible<_base>::value)
0083       : _base(o)
0084   {
0085     _check();
0086   }
0087   //! Explicitly construct from any similarly erased status code
0088   explicit errored_status_code(_base &&o) noexcept(std::is_nothrow_move_constructible<_base>::value)
0089       : _base(static_cast<_base &&>(o))
0090   {
0091     _check();
0092   }
0093
0094   /***** KEEP THESE IN SYNC WITH STATUS_CODE *****/
0095   //! Implicit construction from any type where an ADL discovered `make_status_code(T, Args ...)` returns a `status_code`.
0096   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(
0097   class T, class... Args,  //
0098   class MakeStatusCodeResult =
0099   typename detail::safe_get_make_status_code_result<T, Args...>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0100   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(!std::is_same<typename std::decay<T>::type, errored_status_code>::value       // not copy/move of self
0101                                               && !std::is_same<typename std::decay<T>::type, in_place_t>::value             // not in_place_t
0102                                               && is_status_code<MakeStatusCodeResult>::value                                // ADL makes a status code
0103                                               && std::is_constructible<errored_status_code, MakeStatusCodeResult>::value))  // ADLed status code is compatible
0104   errored_status_code(T &&v, Args &&...args) noexcept(noexcept(make_status_code(std::declval<T>(), std::declval<Args>()...)))  // NOLINT
0105       : errored_status_code(make_status_code(static_cast<T &&>(v), static_cast<Args &&>(args)...))
0106   {
0107     _check();
0108   }
0109
0110   //! Implicit construction from any `quick_status_code_from_enum<Enum>` enumerated type.
0111   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class Enum,                                                                                      //
0112                          class QuickStatusCodeType = typename quick_status_code_from_enum<Enum>::code_type)               // Enumeration has been activated
0113   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(std::is_constructible<errored_status_code, QuickStatusCodeType>::value))    // Its status code is compatible
0114   errored_status_code(Enum &&v) noexcept(std::is_nothrow_constructible<errored_status_code, QuickStatusCodeType>::value)  // NOLINT
0115       : errored_status_code(QuickStatusCodeType(static_cast<Enum &&>(v)))
0116   {
0117     _check();
0118   }
0119   //! Explicit in-place construction.
0120   template <class... Args>
0121   explicit errored_status_code(in_place_t _, Args &&...args) noexcept(std::is_nothrow_constructible<value_type, Args &&...>::value)
0122       : _base(_, static_cast<Args &&>(args)...)
0123   {
0124     _check();
0125   }
0126   //! Explicit in-place construction from initialiser list.
0127   template <class T, class... Args>
0128   explicit errored_status_code(in_place_t _, std::initializer_list<T> il,
0129                                Args &&...args) noexcept(std::is_nothrow_constructible<value_type, std::initializer_list<T>, Args &&...>::value)
0130       : _base(_, il, static_cast<Args &&>(args)...)
0131   {
0132     _check();
0133   }
0134   //! Explicit copy construction from a `value_type`.
0135   explicit errored_status_code(const value_type &v) noexcept(std::is_nothrow_copy_constructible<value_type>::value)
0136       : _base(v)
0137   {
0138     _check();
0139   }
0140   //! Explicit move construction from a `value_type`.
0141   explicit errored_status_code(value_type &&v) noexcept(std::is_nothrow_move_constructible<value_type>::value)
0142       : _base(static_cast<value_type &&>(v))
0143   {
0144     _check();
0145   }
0146   /*! Explicit construction from an erased status code. Available only if
0147   `value_type` is trivially copyable or move bitcopying, and `sizeof(status_code) <= sizeof(status_code<erased<>>)`.
0148   Does not check if domains are equal.
0149   */
0150   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class ErasedType)  //
0151   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(detail::domain_value_type_erasure_is_safe<domain_type, detail::erased<ErasedType>>::value))
0152   explicit errored_status_code(const status_code<detail::erased<ErasedType>> &v) noexcept(std::is_nothrow_copy_constructible<value_type>::value)
0153       : errored_status_code(detail::erasure_cast<value_type>(v.value()))  // NOLINT
0154   {
0155     assert(v.domain() == this->domain());  // NOLINT
0156     _check();
0157   }
0158
0159   //! Always false (including at compile time), as errored status codes are never successful.
0160   constexpr bool success() const noexcept { return false; }
0161   //! Return a const reference to the `value_type`.
0162   constexpr const value_type &value() const & noexcept { return this->_value; }
0163 };
0164
0165 namespace traits
0166 {
0167   template <class DomainType> struct is_move_bitcopying<errored_status_code<DomainType>>
0168   {
0169     static constexpr bool value = is_move_bitcopying<typename DomainType::value_type>::value;
0170   };
0171 }  // namespace traits
0172
0173 template <class ErasedType> class errored_status_code<detail::erased<ErasedType>> : public status_code<detail::erased<ErasedType>>
0174 {
0175   using _base = status_code<detail::erased<ErasedType>>;
0176   using _base::success;
0177
0178   void _check()
0179   {
0180     if(_base::success())
0181     {
0182       std::terminate();
0183     }
0184   }
0185
0186 public:
0187   using domain_type = typename _base::domain_type;
0188   using value_type = typename _base::value_type;
0189   using string_ref = typename _base::string_ref;
0190
0191   //! Default construction to empty
0192   errored_status_code() = default;
0193   //! Copy constructor
0194   errored_status_code(const errored_status_code &) = default;
0195   //! Move constructor
0196   errored_status_code(errored_status_code &&) = default;  // NOLINT
0197                                                           //! Copy assignment
0198   errored_status_code &operator=(const errored_status_code &) = default;
0199   //! Move assignment
0200   errored_status_code &operator=(errored_status_code &&) = default;  // NOLINT
0201   ~errored_status_code() = default;
0202
0203   //! Explicitly construct from any similarly erased status code
0204   explicit errored_status_code(const _base &o) noexcept(std::is_nothrow_copy_constructible<_base>::value)
0205       : _base(o)
0206   {
0207     _check();
0208   }
0209   //! Explicitly construct from any similarly erased status code
0210   explicit errored_status_code(_base &&o) noexcept(std::is_nothrow_move_constructible<_base>::value)
0211       : _base(static_cast<_base &&>(o))
0212   {
0213     _check();
0214   }
0215
0216   /***** KEEP THESE IN SYNC WITH STATUS_CODE *****/
0217   //! Implicit copy construction from any other status code if its value type is trivially copyable, it would fit into our storage, and it is not an erased
0218   //! status code.
0219   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType)  //
0220   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(detail::domain_value_type_erasure_is_safe<detail::erased<ErasedType>, DomainType>::value),
0221                           BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(!detail::is_erased_status_code<status_code<typename std::decay<DomainType>::type>>::value))
0222   errored_status_code(const status_code<DomainType> &v) noexcept
0223       : _base(v)  // NOLINT
0224   {
0225     _check();
0226   }
0227   //! Implicit copy construction from any other status code if its value type is trivially copyable and it would fit into our storage, and it is not an erased
0228   //! status code.
0229   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType)  //
0230   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(detail::domain_value_type_erasure_is_safe<detail::erased<ErasedType>, DomainType>::value),
0231                           BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(!detail::is_erased_status_code<status_code<typename std::decay<DomainType>::type>>::value))
0232   errored_status_code(const errored_status_code<DomainType> &v) noexcept
0233       : _base(static_cast<const status_code<DomainType> &>(v))  // NOLINT
0234   {
0235     _check();
0236   }
0237   //! Implicit move construction from any other status code if its value type is trivially copyable or move bitcopying and it would fit into our storage
0238   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType)  //
0239   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(detail::domain_value_type_erasure_is_safe<detail::erased<ErasedType>, DomainType>::value))
0240   errored_status_code(status_code<DomainType> &&v) noexcept
0241       : _base(static_cast<status_code<DomainType> &&>(v))  // NOLINT
0242   {
0243     _check();
0244   }
0245   //! Implicit move construction from any other status code if its value type is trivially copyable or move bitcopying and it would fit into our storage
0246   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType)  //
0247   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(detail::domain_value_type_erasure_is_safe<detail::erased<ErasedType>, DomainType>::value))
0248   errored_status_code(errored_status_code<DomainType> &&v) noexcept
0249       : _base(static_cast<status_code<DomainType> &&>(v))  // NOLINT
0250   {
0251     _check();
0252   }
0253   //! Implicit construction from any type where an ADL discovered `make_status_code(T, Args ...)` returns a `status_code`.
0254   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(
0255   class T, class... Args,  //
0256   class MakeStatusCodeResult =
0257   typename detail::safe_get_make_status_code_result<T, Args...>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0258   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(!std::is_same<typename std::decay<T>::type, errored_status_code>::value       // not copy/move of self
0259                                               && !std::is_same<typename std::decay<T>::type, value_type>::value             // not copy/move of value type
0260                                               && is_status_code<MakeStatusCodeResult>::value                                // ADL makes a status code
0261                                               && std::is_constructible<errored_status_code, MakeStatusCodeResult>::value))  // ADLed status code is compatible
0262   errored_status_code(T &&v, Args &&...args) noexcept(noexcept(make_status_code(std::declval<T>(), std::declval<Args>()...)))  // NOLINT
0263       : errored_status_code(make_status_code(static_cast<T &&>(v), static_cast<Args &&>(args)...))
0264   {
0265     _check();
0266   }
0267   //! Implicit construction from any `quick_status_code_from_enum<Enum>` enumerated type.
0268   BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class Enum,                                                                                      //
0269                          class QuickStatusCodeType = typename quick_status_code_from_enum<Enum>::code_type)               // Enumeration has been activated
0270   BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(std::is_constructible<errored_status_code, QuickStatusCodeType>::value))    // Its status code is compatible
0271   errored_status_code(Enum &&v) noexcept(std::is_nothrow_constructible<errored_status_code, QuickStatusCodeType>::value)  // NOLINT
0272       : errored_status_code(QuickStatusCodeType(static_cast<Enum &&>(v)))
0273   {
0274     _check();
0275   }
0276 #if defined(_CPPUNWIND) || defined(__EXCEPTIONS) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE)
0277   //! Explicit copy construction from an unknown status code. Note that this will be empty if its value type is not trivially copyable or would not fit into our
0278   //! storage or the source domain's `_do_erased_copy()` refused the copy.
0279   explicit errored_status_code(in_place_t _, const status_code<void> &v)  // NOLINT
0280       : _base(_, v)
0281   {
0282     _check();
0283   }
0284 #endif
0285
0286   //! Always false (including at compile time), as errored status codes are never successful.
0287   constexpr bool success() const noexcept { return false; }
0288   //! Return the erased `value_type` by value.
0289   constexpr value_type value() const noexcept { return this->_value; }
0290 };
0291 /*! An erased type specialisation of `errored_status_code<D>`.
0292 Available only if `ErasedType` satisfies `traits::is_move_bitcopying<ErasedType>::value`.
0293 */
0294 template <class ErasedType> using erased_errored_status_code = errored_status_code<detail::erased<ErasedType>>;
0295
0296
0297 namespace traits
0298 {
0299   template <class ErasedType> struct is_move_bitcopying<errored_status_code<detail::erased<ErasedType>>>
0300   {
0301     static constexpr bool value = true;
0302   };
0303 }  // namespace traits
0304
0305
0306 //! True if the status code's are semantically equal via `equivalent()`.
0307 template <class DomainType1, class DomainType2>
0308 inline bool operator==(const errored_status_code<DomainType1> &a, const errored_status_code<DomainType2> &b) noexcept
0309 {
0310   return a.equivalent(static_cast<const status_code<DomainType2> &>(b));
0311 }
0312 //! True if the status code's are semantically equal via `equivalent()`.
0313 template <class DomainType1, class DomainType2> inline bool operator==(const status_code<DomainType1> &a, const errored_status_code<DomainType2> &b) noexcept
0314 {
0315   return a.equivalent(static_cast<const status_code<DomainType2> &>(b));
0316 }
0317 //! True if the status code's are semantically equal via `equivalent()`.
0318 template <class DomainType1, class DomainType2> inline bool operator==(const errored_status_code<DomainType1> &a, const status_code<DomainType2> &b) noexcept
0319 {
0320   return static_cast<const status_code<DomainType1> &>(a).equivalent(b);
0321 }
0322 //! True if the status code's are not semantically equal via `equivalent()`.
0323 template <class DomainType1, class DomainType2>
0324 inline bool operator!=(const errored_status_code<DomainType1> &a, const errored_status_code<DomainType2> &b) noexcept
0325 {
0326   return !a.equivalent(static_cast<const status_code<DomainType2> &>(b));
0327 }
0328 //! True if the status code's are not semantically equal via `equivalent()`.
0329 template <class DomainType1, class DomainType2> inline bool operator!=(const status_code<DomainType1> &a, const errored_status_code<DomainType2> &b) noexcept
0330 {
0331   return !a.equivalent(static_cast<const status_code<DomainType2> &>(b));
0332 }
0333 //! True if the status code's are not semantically equal via `equivalent()`.
0334 template <class DomainType1, class DomainType2> inline bool operator!=(const errored_status_code<DomainType1> &a, const status_code<DomainType2> &b) noexcept
0335 {
0336   return !static_cast<const status_code<DomainType1> &>(a).equivalent(b);
0337 }
0338 //! True if the status code's are semantically equal via `equivalent()` to `make_status_code(T)`.
0339 BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType1, class T,  //
0340                        class MakeStatusCodeResult =
0341                        typename detail::safe_get_make_status_code_result<const T &>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0342 BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(is_status_code<MakeStatusCodeResult>::value))   // ADL makes a status code
0343 inline bool operator==(const errored_status_code<DomainType1> &a, const T &b)
0344 {
0345   return a.equivalent(make_status_code(b));
0346 }
0347 //! True if the status code's are semantically equal via `equivalent()` to `make_status_code(T)`.
0348 BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class T, class DomainType1,  //
0349                        class MakeStatusCodeResult =
0350                        typename detail::safe_get_make_status_code_result<const T &>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0351 BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(is_status_code<MakeStatusCodeResult>::value))   // ADL makes a status code
0352 inline bool operator==(const T &a, const errored_status_code<DomainType1> &b)
0353 {
0354   return b.equivalent(make_status_code(a));
0355 }
0356 //! True if the status code's are not semantically equal via `equivalent()` to `make_status_code(T)`.
0357 BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class DomainType1, class T,  //
0358                        class MakeStatusCodeResult =
0359                        typename detail::safe_get_make_status_code_result<const T &>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0360 BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(is_status_code<MakeStatusCodeResult>::value))   // ADL makes a status code
0361 inline bool operator!=(const errored_status_code<DomainType1> &a, const T &b)
0362 {
0363   return !a.equivalent(make_status_code(b));
0364 }
0365 //! True if the status code's are semantically equal via `equivalent()` to `make_status_code(T)`.
0366 BOOST_OUTCOME_SYSTEM_ERROR2_TEMPLATE(class T, class DomainType1,  //
0367                        class MakeStatusCodeResult =
0368                        typename detail::safe_get_make_status_code_result<const T &>::type)  // Safe ADL lookup of make_status_code(), returns void if not found
0369 BOOST_OUTCOME_SYSTEM_ERROR2_TREQUIRES(BOOST_OUTCOME_SYSTEM_ERROR2_TPRED(is_status_code<MakeStatusCodeResult>::value))   // ADL makes a status code
0370 inline bool operator!=(const T &a, const errored_status_code<DomainType1> &b)
0371 {
0372   return !b.equivalent(make_status_code(a));
0373 }
0374 //! True if the status code's are semantically equal via `equivalent()` to `quick_status_code_from_enum<T>::code_type(b)`.
0375 template <class DomainType1, class T,                                                     //
0376           class QuickStatusCodeType = typename quick_status_code_from_enum<T>::code_type  // Enumeration has been activated
0377           >
0378 inline bool operator==(const errored_status_code<DomainType1> &a, const T &b)
0379 {
0380   return a.equivalent(QuickStatusCodeType(b));
0381 }
0382 //! True if the status code's are semantically equal via `equivalent()` to `quick_status_code_from_enum<T>::code_type(a)`.
0383 template <class T, class DomainType1,                                                     //
0384           class QuickStatusCodeType = typename quick_status_code_from_enum<T>::code_type  // Enumeration has been activated
0385           >
0386 inline bool operator==(const T &a, const errored_status_code<DomainType1> &b)
0387 {
0388   return b.equivalent(QuickStatusCodeType(a));
0389 }
0390 //! True if the status code's are not semantically equal via `equivalent()` to `quick_status_code_from_enum<T>::code_type(b)`.
0391 template <class DomainType1, class T,                                                     //
0392           class QuickStatusCodeType = typename quick_status_code_from_enum<T>::code_type  // Enumeration has been activated
0393           >
0394 inline bool operator!=(const errored_status_code<DomainType1> &a, const T &b)
0395 {
0396   return !a.equivalent(QuickStatusCodeType(b));
0397 }
0398 //! True if the status code's are not semantically equal via `equivalent()` to `quick_status_code_from_enum<T>::code_type(a)`.
0399 template <class T, class DomainType1,                                                     //
0400           class QuickStatusCodeType = typename quick_status_code_from_enum<T>::code_type  // Enumeration has been activated
0401           >
0402 inline bool operator!=(const T &a, const errored_status_code<DomainType1> &b)
0403 {
0404   return !b.equivalent(QuickStatusCodeType(a));
0405 }
0406
0407
0408 namespace detail
0409 {
0410   template <class T> struct is_errored_status_code
0411   {
0412     static constexpr bool value = false;
0413   };
0414   template <class T> struct is_errored_status_code<errored_status_code<T>>
0415   {
0416     static constexpr bool value = true;
0417   };
0418   template <class T> struct is_erased_errored_status_code
0419   {
0420     static constexpr bool value = false;
0421   };
0422   template <class T> struct is_erased_errored_status_code<errored_status_code<erased<T>>>
0423   {
0424     static constexpr bool value = true;
0425   };
0426 }  // namespace detail
0427
0428 //! Trait returning true if the type is an errored status code.
0429 template <class T> struct is_errored_status_code
0430 {
0431   static constexpr bool value =
0432   detail::is_errored_status_code<typename std::decay<T>::type>::value || detail::is_erased_errored_status_code<typename std::decay<T>::type>::value;
0433 };
0434
0435
0436 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END
0437
0438 #endif