mdbx++: добавление slice::as_pod<typename>().

src/mdbx.c++

@@ -233,6 +233,10 @@ namespace mdbx {
       "into an incompatible memory allocation scheme.");
 }
 
+[[noreturn]] __cold void throw_bad_value_size() {
+  throw bad_value_size(MDBX_BAD_VALSIZE);
+}
+
 __cold exception::exception(const ::mdbx::error &error) noexcept
     : base(error.what()), error_(error) {}
 
@@ -483,6 +487,109 @@ bool slice::is_printable(bool disable_utf8) const noexcept {
   return true;
 }
 
+#ifdef MDBX_U128_TYPE
+MDBX_U128_TYPE slice::as_uint128() const {
+  static_assert(sizeof(MDBX_U128_TYPE) == 16, "WTF?");
+  if (size() == 16) {
+    MDBX_U128_TYPE r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_uint64();
+}
+#endif /* MDBX_U128_TYPE */
+
+uint64_t slice::as_uint64() const {
+  static_assert(sizeof(uint64_t) == 8, "WTF?");
+  if (size() == 8) {
+    uint64_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_uint32();
+}
+
+uint32_t slice::as_uint32() const {
+  static_assert(sizeof(uint32_t) == 4, "WTF?");
+  if (size() == 4) {
+    uint32_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_uint16();
+}
+
+uint16_t slice::as_uint16() const {
+  static_assert(sizeof(uint16_t) == 2, "WTF?");
+  if (size() == 2) {
+    uint16_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_uint8();
+}
+
+uint8_t slice::as_uint8() const {
+  static_assert(sizeof(uint8_t) == 1, "WTF?");
+  if (size() == 1)
+    return *static_cast<const uint8_t *>(data());
+  else if (size() == 0)
+    return 0;
+  else
+    MDBX_CXX20_UNLIKELY throw_bad_value_size();
+}
+
+#ifdef MDBX_I128_TYPE
+MDBX_I128_TYPE slice::as_int128() const {
+  static_assert(sizeof(MDBX_I128_TYPE) == 16, "WTF?");
+  if (size() == 16) {
+    MDBX_I128_TYPE r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_int64();
+}
+#endif /* MDBX_I128_TYPE */
+
+int64_t slice::as_int64() const {
+  static_assert(sizeof(int64_t) == 8, "WTF?");
+  if (size() == 8) {
+    uint64_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_int32();
+}
+
+int32_t slice::as_int32() const {
+  static_assert(sizeof(int32_t) == 4, "WTF?");
+  if (size() == 4) {
+    int32_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_int16();
+}
+
+int16_t slice::as_int16() const {
+  static_assert(sizeof(int16_t) == 2, "WTF?");
+  if (size() == 2) {
+    int16_t r;
+    memcpy(&r, data(), sizeof(r));
+    return r;
+  } else
+    return as_int8();
+}
+
+int8_t slice::as_int8() const {
+  if (size() == 1)
+    return *static_cast<const int8_t *>(data());
+  else if (size() == 0)
+    return 0;
+  else
+    MDBX_CXX20_UNLIKELY throw_bad_value_size();
+}
+
 //------------------------------------------------------------------------------
 
 char *to_hex::write_bytes(char *__restrict const dest, size_t dest_size) const {