/* Proposed SG14 status_code (C) 2018 - 2020 Niall Douglas <http://www.nedproductions.biz/> (5 commits) File Created: May 2020 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License in the accompanying file Licence.txt or at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Distributed under the Boost Software License, Version 1.0. (See accompanying file Licence.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_HPP #define BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_HPP #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES #define BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES 1 #endif #include "generic_code.hpp" BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN template <class Enum> class _quick_status_code_from_enum_domain; //! A status code wrapping `Enum` generated from `quick_status_code_from_enum`. template <class Enum> using quick_status_code_from_enum_code = status_code<_quick_status_code_from_enum_domain<Enum>>; //! Defaults for an implementation of `quick_status_code_from_enum<Enum>` template <class Enum> struct quick_status_code_from_enum_defaults { //! The type of the resulting code using code_type = quick_status_code_from_enum_code<Enum>; //! Used within `quick_status_code_from_enum` to define a mapping of enumeration value with its status code struct mapping { //! The enumeration type using enumeration_type = Enum; //! The value being mapped const Enum value; //! A string representation for this enumeration value const char *message; //! A list of `errc` equivalents for this enumeration value const std::initializer_list<errc> code_mappings; }; //! Used within `quick_status_code_from_enum` to define mixins for the status code wrapping `Enum` template <class Base> struct mixin : Base { using Base::Base; }; }; /*! The implementation of the domain for status codes wrapping `Enum` generated from `quick_status_code_from_enum`. */ template <class Enum> class _quick_status_code_from_enum_domain : public status_code_domain { template <class DomainType> friend class status_code; using _base = status_code_domain; using _src = quick_status_code_from_enum<Enum>; public: //! The value type of the quick status code from enum using value_type = Enum; using _base::string_ref; constexpr _quick_status_code_from_enum_domain() : status_code_domain(_src::domain_uuid, _uuid_size<detail::cstrlen(_src::domain_uuid)>()) { } _quick_status_code_from_enum_domain(const _quick_status_code_from_enum_domain &) = default; _quick_status_code_from_enum_domain(_quick_status_code_from_enum_domain &&) = default; _quick_status_code_from_enum_domain &operator=(const _quick_status_code_from_enum_domain &) = default; _quick_status_code_from_enum_domain &operator=(_quick_status_code_from_enum_domain &&) = default; ~_quick_status_code_from_enum_domain() = default; #if __cplusplus < 201402L && !defined(_MSC_VER) static inline const _quick_status_code_from_enum_domain &get() { static _quick_status_code_from_enum_domain v; return v; } #else static inline constexpr const _quick_status_code_from_enum_domain &get(); #endif virtual string_ref name() const noexcept override { return string_ref(_src::domain_name); } virtual payload_info_t payload_info() const noexcept override { return {sizeof(value_type), sizeof(status_code_domain *) + sizeof(value_type), (alignof(value_type) > alignof(status_code_domain *)) ? alignof(value_type) : alignof(status_code_domain *)}; } protected: // Not sure if a hash table is worth it here, most enumerations won't be long enough to be worth it // Also, until C++ 20's consteval, the hash table would get emitted into the binary, bloating it static BOOST_OUTCOME_SYSTEM_ERROR2_CONSTEXPR14 const typename _src::mapping *_find_mapping(value_type v) noexcept { for(const auto &i : _src::value_mappings()) { if(i.value == v) { return &i; } } return nullptr; } virtual bool _do_failure(const status_code<void> &code) const noexcept override { assert(code.domain() == *this); // NOLINT // If `errc::success` is in the generic code mapping, it is not a failure const auto *mapping = _find_mapping(static_cast<const quick_status_code_from_enum_code<value_type> &>(code).value()); #if BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES assert(mapping != nullptr); // if this fires, you forgot to add the enum to the mapping table #endif if(mapping != nullptr) { for(errc ec : mapping->code_mappings) { if(ec == errc::success) { return false; } } } return true; } virtual bool _do_equivalent(const status_code<void> &code1, const status_code<void> &code2) const noexcept override { assert(code1.domain() == *this); // NOLINT const auto &c1 = static_cast<const quick_status_code_from_enum_code<value_type> &>(code1); // NOLINT if(code2.domain() == *this) { const auto &c2 = static_cast<const quick_status_code_from_enum_code<value_type> &>(code2); // NOLINT return c1.value() == c2.value(); } if(code2.domain() == generic_code_domain) { const auto &c2 = static_cast<const generic_code &>(code2); // NOLINT const auto *mapping = _find_mapping(c1.value()); #if BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES assert(mapping != nullptr); // if this fires, you forgot to add the enum to the mapping table #endif if(mapping != nullptr) { for(errc ec : mapping->code_mappings) { if(ec == c2.value()) { return true; } } } } return false; } virtual generic_code _generic_code(const status_code<void> &code) const noexcept override { assert(code.domain() == *this); // NOLINT const auto *mapping = _find_mapping(static_cast<const quick_status_code_from_enum_code<value_type> &>(code).value()); #if BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES assert(mapping != nullptr); // if this fires, you forgot to add the enum to the mapping table #endif if(mapping != nullptr) { if(mapping->code_mappings.size() > 0) { return *mapping->code_mappings.begin(); } } return errc::unknown; } virtual string_ref _do_message(const status_code<void> &code) const noexcept override { assert(code.domain() == *this); // NOLINT const auto *mapping = _find_mapping(static_cast<const quick_status_code_from_enum_code<value_type> &>(code).value()); #if BOOST_OUTCOME_SYSTEM_ERROR2_QUICK_STATUS_CODE_FROM_ENUM_ASSERT_ON_MISSING_MAPPING_TABLE_ENTRIES assert(mapping != nullptr); // if this fires, you forgot to add the enum to the mapping table #endif if(mapping != nullptr) { return string_ref(mapping->message); } return string_ref("unknown"); } #if defined(_CPPUNWIND) || defined(__EXCEPTIONS) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE) BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN virtual void _do_throw_exception(const status_code<void> &code) const override { assert(code.domain() == *this); // NOLINT const auto &c = static_cast<const quick_status_code_from_enum_code<value_type> &>(code); // NOLINT throw status_error<_quick_status_code_from_enum_domain>(c); } #endif }; #if __cplusplus >= 201402L || defined(_MSC_VER) template <class Enum> constexpr _quick_status_code_from_enum_domain<Enum> quick_status_code_from_enum_domain = {}; template <class Enum> inline constexpr const _quick_status_code_from_enum_domain<Enum> &_quick_status_code_from_enum_domain<Enum>::get() { return quick_status_code_from_enum_domain<Enum>; } #endif namespace mixins { template <class Base, class Enum> struct mixin<Base, _quick_status_code_from_enum_domain<Enum>> : public quick_status_code_from_enum<Enum>::template mixin<Base> { using quick_status_code_from_enum<Enum>::template mixin<Base>::mixin; }; } // namespace mixins BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END #endif