ceph/src/boost/boost/outcome/experimental/status-code/config.hpp

   1 /* Proposed SG14 status_code
   2 (C) 2018 - 2020 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
   3 File Created: Feb 2018
   4
   5
   6 Licensed under the Apache License, Version 2.0 (the "License");
   7 you may not use this file except in compliance with the License.
   8 You may obtain a copy of the License in the accompanying file
   9 Licence.txt or at
  10
  11 http://www.apache.org/licenses/LICENSE-2.0
  12
  13 Unless required by applicable law or agreed to in writing, software
  14 distributed under the License is distributed on an "AS IS" BASIS,
  15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 See the License for the specific language governing permissions and
  17 limitations under the License.
  18
  19
  20 Distributed under the Boost Software License, Version 1.0.
  21 (See accompanying file Licence.txt or copy at
  22 http://www.boost.org/LICENSE_1_0.txt)
  23 */
  24
  25 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_CONFIG_HPP
  26 #define BOOST_OUTCOME_SYSTEM_ERROR2_CONFIG_HPP
  27
  28 // < 0.1 each
  29 #include <cassert>
  30 #include <cstddef>  // for size_t
  31 #include <cstdlib>  // for free
  32
  33 // 0.22
  34 #include <type_traits>
  35
  36 // 0.29
  37 #include <atomic>
  38
  39 // 0.28 (0.15 of which is exception_ptr)
  40 #include <exception>  // for std::exception
  41 // <new> includes <exception>, <exception> includes <new>
  42 #include <new>
  43
  44 // 0.01
  45 #include <initializer_list>
  46
  47 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_CONSTEXPR14
  48 #if defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE) || __cplusplus >= 201400 || _MSC_VER >= 1910 /* VS2017 */
  49 //! Defined to be `constexpr` when on C++ 14 or better compilers. Usually automatic, can be overriden.
  50 #define BOOST_OUTCOME_SYSTEM_ERROR2_CONSTEXPR14 constexpr
  51 #else
  52 #define BOOST_OUTCOME_SYSTEM_ERROR2_CONSTEXPR14
  53 #endif
  54 #endif
  55
  56 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN
  57 #if defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE) || (_HAS_CXX17 && _MSC_VER >= 1911 /* VS2017.3 */)
  58 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN [[noreturn]]
  59 #endif
  60 #endif
  61 #if !defined(BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN)
  62 #ifdef __has_cpp_attribute
  63 #if __has_cpp_attribute(noreturn)
  64 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN [[noreturn]]
  65 #endif
  66 #endif
  67 #endif
  68 #if !defined(BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN)
  69 #if defined(_MSC_VER)
  70 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN __declspec(noreturn)
  71 #elif defined(__GNUC__)
  72 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN __attribute__((__noreturn__))
  73 #else
  74 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN
  75 #endif
  76 #endif
  77 // GCCs before 7 don't grok [[noreturn]] virtual functions, and warn annoyingly
  78 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 7
  79 #undef BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN
  80 #define BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN
  81 #endif
  82
  83 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD
  84 #if defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE) || (_HAS_CXX17 && _MSC_VER >= 1911 /* VS2017.3 */)
  85 #define BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD [[nodiscard]]
  86 #endif
  87 #endif
  88 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD
  89 #ifdef __has_cpp_attribute
  90 #if __has_cpp_attribute(nodiscard)
  91 #define BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD [[nodiscard]]
  92 #endif
  93 #elif defined(__clang__)
  94 #define BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD __attribute__((warn_unused_result))
  95 #elif defined(_MSC_VER)
  96 // _Must_inspect_result_ expands into this
  97 #define BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD                                                                                                                                                                                                                                                                                                \
  98   __declspec("SAL_name"                                                                                                                                                                                                                                                                                                        \
  99              "("                                                                                                                                                                                                                                                                                                               \
 100              "\"_Must_inspect_result_\""                                                                                                                                                                                                                                                                                       \
 101              ","                                                                                                                                                                                                                                                                                                               \
 102              "\"\""                                                                                                                                                                                                                                                                                                            \
 103              ","                                                                                                                                                                                                                                                                                                               \
 104              "\"2\""                                                                                                                                                                                                                                                                                                           \
 105              ")") __declspec("SAL_begin") __declspec("SAL_post") __declspec("SAL_mustInspect") __declspec("SAL_post") __declspec("SAL_checkReturn") __declspec("SAL_end")
 106 #endif
 107 #endif
 108 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD
 109 #define BOOST_OUTCOME_SYSTEM_ERROR2_NODISCARD
 110 #endif
 111
 112 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_TRIVIAL_ABI
 113 #if defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE) || (__clang_major__ >= 7 && !defined(__APPLE__))
 114 //! Defined to be `[[clang::trivial_abi]]` when on a new enough clang compiler. Usually automatic, can be overriden.
 115 #define BOOST_OUTCOME_SYSTEM_ERROR2_TRIVIAL_ABI [[clang::trivial_abi]]
 116 #else
 117 #define BOOST_OUTCOME_SYSTEM_ERROR2_TRIVIAL_ABI
 118 #endif
 119 #endif
 120
 121 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE
 122 //! The system_error2 namespace name.
 123 #define BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE system_error2
 124 //! Begins the system_error2 namespace.
 125 #define BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN                                                                                                                                                                                                                                                                                          \
 126   namespace system_error2                                                                                                                                                                                                                                                                                                      \
 127   {
 128 //! Ends the system_error2 namespace.
 129 #define BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END }
 130 #endif
 131
 132 //! Namespace for the library
 133 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN
 134
 135 //! Namespace for user specialised traits
 136 namespace traits
 137 {
 138   /*! Specialise to true if you guarantee that a type is move bitcopying (i.e.
 139   its move constructor equals copying bits from old to new, old is left in a
 140   default constructed state, and calling the destructor on a default constructed
 141   instance is trivial). All trivially copyable types are move bitcopying by
 142   definition, and that is the unspecialised implementation.
 143   */
 144   template <class T> struct is_move_bitcopying
 145   {
 146     static constexpr bool value = std::is_trivially_copyable<T>::value;
 147   };
 148 }  // namespace traits
 149
 150 namespace detail
 151 {
 152 #if __cplusplus >= 201400 || _MSC_VER >= 1910 /* VS2017 */
 153   inline constexpr size_t cstrlen(const char *str)
 154   {
 155     const char *end = nullptr;
 156     for(end = str; *end != 0; ++end)  // NOLINT
 157       ;
 158     return end - str;
 159   }
 160 #else
 161   inline constexpr size_t cstrlen_(const char *str, size_t acc)
 162   {
 163     return (str[0] == 0) ? acc : cstrlen_(str + 1, acc + 1);
 164   }
 165   inline constexpr size_t cstrlen(const char *str)
 166   {
 167     return cstrlen_(str, 0);
 168   }
 169 #endif
 170
 171   /* A partially compliant implementation of C++20's std::bit_cast function contributed
 172   by Jesse Towner. TODO FIXME Replace with C++ 20 bit_cast when available.
 173
 174   Our bit_cast is only guaranteed to be constexpr when both the input and output
 175   arguments are either integrals or enums. However, this covers most use cases
 176   since the vast majority of status_codes have an underlying type that is either
 177   an integral or enum. We still attempt a constexpr union-based type pun for non-array
 178   input types, which some compilers accept. For array inputs, we fall back to
 179   non-constexpr memmove.
 180   */
 181
 182   template <class T> using is_integral_or_enum = std::integral_constant<bool, std::is_integral<T>::value || std::is_enum<T>::value>;
 183
 184   template <class To, class From> using is_static_castable = std::integral_constant<bool, is_integral_or_enum<To>::value && is_integral_or_enum<From>::value>;
 185
 186   template <class To, class From> using is_union_castable = std::integral_constant<bool, !is_static_castable<To, From>::value && !std::is_array<To>::value && !std::is_array<From>::value>;
 187
 188   template <class To, class From> using is_bit_castable = std::integral_constant<bool, sizeof(To) == sizeof(From) && traits::is_move_bitcopying<To>::value && traits::is_move_bitcopying<From>::value>;
 189
 190   template <class To, class From> union bit_cast_union {
 191     From source;
 192     To target;
 193   };
 194
 195   template <class To, class From,
 196             typename std::enable_if<                 //
 197             is_bit_castable<To, From>::value         //
 198             && is_static_castable<To, From>::value   //
 199             && !is_union_castable<To, From>::value,  //
 200             bool>::type = true>                      //
 201   constexpr To bit_cast(const From &from) noexcept
 202   {
 203     return static_cast<To>(from);
 204   }
 205
 206 #if defined(__GNUC__) && !defined(__clang__)
 207 #pragma GCC diagnostic push
 208 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 209 #endif
 210   template <class To, class From,
 211             typename std::enable_if<                 //
 212             is_bit_castable<To, From>::value         //
 213             && !is_static_castable<To, From>::value  //
 214             && is_union_castable<To, From>::value,   //
 215             bool>::type = true>                      //
 216   constexpr To bit_cast(const From &from) noexcept
 217   {
 218     return bit_cast_union<To, From>{from}.target;
 219   }
 220 #if defined(__GNUC__) && !defined(__clang__)
 221 #pragma GCC diagnostic pop
 222 #endif
 223
 224   template <class To, class From,
 225             typename std::enable_if<                 //
 226             is_bit_castable<To, From>::value         //
 227             && !is_static_castable<To, From>::value  //
 228             && !is_union_castable<To, From>::value,  //
 229             bool>::type = true>                      //
 230   To bit_cast(const From &from) noexcept
 231   {
 232     bit_cast_union<To, From> ret;
 233     memmove(&ret.source, &from, sizeof(ret.source));
 234     return ret.target;
 235   }
 236
 237   /* erasure_cast performs a bit_cast with additional rules to handle types
 238   of differing sizes. For integral & enum types, it may perform a narrowing
 239   or widing conversion with static_cast if necessary, before doing the final
 240   conversion with bit_cast. When casting to or from non-integral, non-enum
 241   types it may insert the value into another object with extra padding bytes
 242   to satisfy bit_cast's preconditions that both types have the same size. */
 243
 244   template <class To, class From> using is_erasure_castable = std::integral_constant<bool, traits::is_move_bitcopying<To>::value && traits::is_move_bitcopying<From>::value>;
 245
 246   template <class T, bool = std::is_enum<T>::value> struct identity_or_underlying_type
 247   {
 248     using type = T;
 249   };
 250   template <class T> struct identity_or_underlying_type<T, true>
 251   {
 252     using type = typename std::underlying_type<T>::type;
 253   };
 254
 255   template <class OfSize, class OfSign>
 256   using erasure_integer_type = typename std::conditional<std::is_signed<typename identity_or_underlying_type<OfSign>::type>::value, typename std::make_signed<typename identity_or_underlying_type<OfSize>::type>::type, typename std::make_unsigned<typename identity_or_underlying_type<OfSize>::type>::type>::type;
 257
 258   template <class ErasedType, std::size_t N> struct padded_erasure_object
 259   {
 260     static_assert(traits::is_move_bitcopying<ErasedType>::value, "ErasedType must be TriviallyCopyable or MoveBitcopying");
 261     static_assert(alignof(ErasedType) <= sizeof(ErasedType), "ErasedType must not be over-aligned");
 262     ErasedType value;
 263     char padding[N];
 264     constexpr explicit padded_erasure_object(const ErasedType &v) noexcept
 265         : value(v)
 266         , padding{}
 267     {
 268     }
 269   };
 270
 271   template <class To, class From, typename std::enable_if<is_erasure_castable<To, From>::value && (sizeof(To) == sizeof(From)), bool>::type = true> constexpr To erasure_cast(const From &from) noexcept { return bit_cast<To>(from); }
 272
 273   template <class To, class From, typename std::enable_if<is_erasure_castable<To, From>::value && is_static_castable<To, From>::value && (sizeof(To) < sizeof(From)), bool>::type = true> constexpr To erasure_cast(const From &from) noexcept { return static_cast<To>(bit_cast<erasure_integer_type<From, To>>(from)); }
 274
 275   template <class To, class From, typename std::enable_if<is_erasure_castable<To, From>::value && is_static_castable<To, From>::value && (sizeof(To) > sizeof(From)), bool>::type = true> constexpr To erasure_cast(const From &from) noexcept { return bit_cast<To>(static_cast<erasure_integer_type<To, From>>(from)); }
 276
 277   template <class To, class From, typename std::enable_if<is_erasure_castable<To, From>::value && !is_static_castable<To, From>::value && (sizeof(To) < sizeof(From)), bool>::type = true> constexpr To erasure_cast(const From &from) noexcept
 278   {
 279     return bit_cast<padded_erasure_object<To, sizeof(From) - sizeof(To)>>(from).value;
 280   }
 281
 282   template <class To, class From, typename std::enable_if<is_erasure_castable<To, From>::value && !is_static_castable<To, From>::value && (sizeof(To) > sizeof(From)), bool>::type = true> constexpr To erasure_cast(const From &from) noexcept
 283   {
 284     return bit_cast<To>(padded_erasure_object<From, sizeof(To) - sizeof(From)>{from});
 285   }
 286 }  // namespace detail
 287 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END
 288
 289 #ifndef BOOST_OUTCOME_SYSTEM_ERROR2_FATAL
 290 #ifdef BOOST_OUTCOME_SYSTEM_ERROR2_NOT_POSIX
 291 #error If BOOST_OUTCOME_SYSTEM_ERROR2_NOT_POSIX is defined, you must define your own BOOST_OUTCOME_SYSTEM_ERROR2_FATAL implementation!
 292 #endif
 293 #include <cstdlib>  // for abort
 294 #ifdef __APPLE__
 295 #include <unistd.h>  // for write
 296 #endif
 297
 298 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_BEGIN
 299 namespace detail
 300 {
 301   namespace avoid_stdio_include
 302   {
 303 #if !defined(__APPLE__) && !defined(_MSC_VER)
 304     extern "C" ptrdiff_t write(int, const void *, size_t);
 305 #elif defined(_MSC_VER)
 306     extern ptrdiff_t write(int, const void *, size_t);
 307 #if defined(_WIN64)
 308 #pragma comment(linker, "/alternatename:?write@avoid_stdio_include@detail@system_error2@@YA_JHPEBX_K@Z=write")
 309 #else
 310 #pragma comment(linker, "/alternatename:?write@avoid_stdio_include@detail@system_error2@@YAHHPBXI@Z=_write")
 311 #endif
 312 #endif
 313   }  // namespace avoid_stdio_include
 314   inline void do_fatal_exit(const char *msg)
 315   {
 316     using namespace avoid_stdio_include;
 317     write(2 /*stderr*/, msg, cstrlen(msg));
 318     write(2 /*stderr*/, "\n", 1);
 319     abort();
 320   }
 321 }  // namespace detail
 322 BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE_END
 323 //! Prints msg to stderr, and calls `std::terminate()`. Can be overriden via predefinition.
 324 #define BOOST_OUTCOME_SYSTEM_ERROR2_FATAL(msg) ::BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::detail::do_fatal_exit(msg)
 325 #endif
 326
 327 #endif