utils.hpp

Go to the documentation of this file.

#pragma once
#ifndef _MDBX_CONTAINERS_UTILS_HPP_INCLUDED
#define _MDBX_CONTAINERS_UTILS_HPP_INCLUDED


 
#if __cplusplus >= 201703L
#   define MDBXC_NODISCARD [[nodiscard]]
#else
#   define MDBXC_NODISCARD
#endif
 
namespace mdbxc {
    
    void check_mdbx(int rc, const std::string& context) {
        if (rc != MDBX_SUCCESS) {
            throw MdbxException(context + ": (" + std::to_string(rc) + ") " + std::string(mdbx_strerror(rc)), rc);
        }
    }
    
    inline uint32_t sortable_key_from_float(float f) {
        uint32_t u; 
        std::memcpy(&u, &f, sizeof(uint32_t));
        return (u & 0x80000000u) ? ~u : (u ^ 0x80000000u);
    }
    
    inline uint64_t sortable_key_from_double(double d) {
        uint64_t u; 
        std::memcpy(&u, &d, sizeof(uint64_t));
        return (u & 0x8000000000000000ull) ? ~u : (u ^ 0x8000000000000000ull);
    }
    
    // --- Traits --- 

    template <typename T>
    struct has_to_bytes {
    private:
        template <typename U>
        static auto check(U*) -> decltype(std::declval<const U>().to_bytes(), std::true_type());
        template <typename>
        static std::false_type check(...);
    public:
        static const bool value = decltype(check<T>(0))::value;
    };

    template <typename T>
    struct has_from_bytes {
    private:
        template <typename U>
        static auto check(U*) -> decltype(U::from_bytes((const void*)0, size_t(0)), std::true_type());
        template <typename>
        static std::false_type check(...);
    public:
        static const bool value = decltype(check<T>(0))::value;
    };

    template <typename T>
    struct has_value_type {
    private:
        template <typename U>
        static auto check(U*) -> decltype(typename U::value_type(), std::true_type());
        template <typename>
        static std::false_type check(...);
    public:
        static const bool value = decltype(check<T>(0))::value;
    };
 
//-----------------------------------------------------------------------------
    
    template<typename T>
    inline MDBX_db_flags_t get_mdbx_flags() {
        return
            std::is_same<T, int>::value || std::is_same<T, int32_t>::value ||
            std::is_same<T, uint32_t>::value || std::is_same<T, int64_t>::value ||
            std::is_same<T, uint64_t>::value || std::is_same<T, float>::value ||
            std::is_same<T, double>::value || std::is_same<T, char>::value ||
            std::is_same<T, unsigned char>::value
            ? MDBX_INTEGERKEY : static_cast<MDBX_db_flags_t>(0);
    }
    
//-----------------------------------------------------------------------------
    
    template<typename T>
    size_t get_key_size(const T& key) {
        // std::string
        if (std::is_same<T, std::string>::value) {
            return key.size();
        }
 
        // 32-bit types
        if (std::is_same<T, int>::value ||
            std::is_same<T, int32_t>::value ||
            std::is_same<T, uint32_t>::value ||
            std::is_same<T, float>::value) {
            return sizeof(uint32_t);
        }
 
        // 64-bit types
        if (std::is_same<T, int64_t>::value ||
            std::is_same<T, uint64_t>::value ||
            std::is_same<T, double>::value) {
            return sizeof(uint64_t);
        }
 
        // byte vectors
        if (
#           if __cplusplus >= 201703L
            std::is_same<T, std::vector<std::byte> >::value ||
#           endif
            std::is_same<T, std::vector<uint8_t> >::value ||
            std::is_same<T, std::vector<char> >::value ||
            std::is_same<T, std::vector<unsigned char> >::value) {
            return key.size();
        }
 
        // fallback
        return sizeof(T);
    }
    
    struct SerializeScratch {
        alignas(8) unsigned char small[16]; 
        std::vector<uint8_t> bytes; 

        MDBXC_NODISCARD static inline MDBX_val view(const void* p, size_t n) noexcept {
            MDBX_val v;
            v.iov_base = (n ? const_cast<void*>(p) : nullptr);
            v.iov_len  = n;
            return v;
        }

        MDBXC_NODISCARD inline MDBX_val view_copy(const void* p, size_t n) {
            bytes.clear();
            bytes.resize(n);
            if (n) std::memcpy(bytes.data(), p, n);
            MDBX_val v;
            v.iov_base = (bytes.empty() ? nullptr : static_cast<void*>(bytes.data()));
            v.iov_len  = bytes.size();
            return v;
        }
        
        MDBXC_NODISCARD inline MDBX_val view_bytes() const noexcept {
            MDBX_val v;
            v.iov_base = (bytes.empty() ? nullptr : const_cast<void*>(static_cast<const void*>(bytes.data())));
            v.iov_len  = bytes.size();
            return v;
        }
        
        MDBXC_NODISCARD inline MDBX_val view_small_copy(const void* p, size_t n) noexcept {
            std::memcpy(small, p, n);
            MDBX_val v; 
            v.iov_base = (n ? static_cast<void*>(small) : nullptr); 
            v.iov_len = n; 
            return v;
        }

        inline void assign_bytes(const void* p, size_t n) {
            bytes.clear();
            bytes.resize(n);
            if (n) std::memcpy(bytes.data(), p, n);
        }

        inline void clear() noexcept { bytes.clear(); bytes.shrink_to_fit(); }
    };
 
    // --- serialize_key overloads ---
 

    template <typename T>
    typename std::enable_if<!has_to_bytes<T>::value && !std::is_same<T, std::string>::value && !std::is_trivially_copyable<T>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        (void)key; 
        (void)sc;
        static_assert(sizeof(T) == 0, "Unsupported type for serialize_key");
        MDBX_val val;
        val.iov_base = nullptr;
        val.iov_len  = 0;
        return val;
    }

    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(key.data()), key.size());
    }

    template<typename T>
    typename std::enable_if<
#       if __cplusplus >= 201703L
        std::is_same<T, std::vector<std::byte>>::value ||
#       endif
        std::is_same<T, std::vector<uint8_t>>::value ||
        std::is_same<T, std::vector<char>>::value ||
        std::is_same<T, std::vector<unsigned char>>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(key.data()), key.size());
    }
    
    template<typename T>
    typename std::enable_if<
        std::is_integral<T>::value &&
        (sizeof(T) <= 2), MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        static_assert(sizeof(uint32_t) == 4, "Expected 4-byte wrapper");
        uint32_t temp = static_cast<uint32_t>(key);
        return sc.view_small_copy(&temp, sizeof(uint32_t));
    }

    template<typename T>
    typename std::enable_if<
        std::is_same<T, int32_t>::value ||
        std::is_same<T, uint32_t>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        static_assert(sizeof(uint32_t) == 4, "Expected 4-byte integer");
#       if MDBXC_SAFE_INTEGERKEY
        return sc.view_small_copy(&key, sizeof(uint32_t));
#       else
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(&key), sizeof(uint32_t));
#       endif
    }
    
    template<typename T>
    typename std::enable_if<
        std::is_same<T, float>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        static_assert(sizeof(uint32_t) == 4, "Expected 4-byte integer");
        uint32_t temp = sortable_key_from_float(key);
        return sc.view_small_copy(&temp, sizeof(uint32_t));
    }

    template<typename T>
    typename std::enable_if<
        std::is_same<T, int64_t>::value ||
        std::is_same<T, uint64_t>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        static_assert(sizeof(uint64_t) == 8, "Expected 8-byte integer");
#       if MDBXC_SAFE_INTEGERKEY
        return sc.view_small_copy(&key, sizeof(uint64_t));
#       else
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(&key), sizeof(uint64_t));
#       endif
    }
    
    template<typename T>
    typename std::enable_if<
        std::is_same<T, double>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        static_assert(sizeof(uint64_t) == 8, "Expected 8-byte integer");
        uint64_t temp = sortable_key_from_double(key);
        return sc.view_small_copy(&temp, sizeof(uint64_t));
    }

    template<typename T>
    typename std::enable_if<
        std::is_trivially_copyable<T>::value &&
        !std::is_same<T, std::string>::value &&
        !(std::is_integral<T>::value && sizeof(T) <= 2) &&
        !std::is_same<T, int32_t>::value &&
        !std::is_same<T, uint32_t>::value &&
        !std::is_same<T, float>::value &&
        !std::is_same<T, int64_t>::value &&
        !std::is_same<T, uint64_t>::value &&
        !std::is_same<T, double>::value, MDBX_val>::type
    serialize_key(const T& key, SerializeScratch& sc) {
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(&key), sizeof(T));
    }

    template <size_t N>
    inline MDBX_val serialize_key(const std::bitset<N>& data, SerializeScratch& sc) {
        const size_t num_bytes = (N + 7) / 8;
        std::array<uint8_t, (N + 7) / 8> buffer;
        buffer.fill(0);
        for (size_t i = 0; i < N; ++i) {
            if (data[i]) buffer[i / 8] |= (1 << (i % 8));
        }
        return sc.view_copy(buffer.data(), num_bytes);
    }
 
    // --- serialize_value overloads ---

    template <typename T>
    typename std::enable_if<
        !has_value_type<T>::value &&
        !std::is_same<T, std::vector<typename T::value_type>>::value &&
        !std::is_trivially_copyable<typename T::value_type>::value &&
        !has_to_bytes<T>::value && 
        !std::is_same<T, std::string>::value &&
        !std::is_trivially_copyable<T>::value, MDBX_val>::type
    serialize_value(const T& value, SerializeScratch& sc) {
        (void)value; 
        (void)sc;
        static_assert(sizeof(T) == 0, "Unsupported type for serialize_value");
        MDBX_val val;
        val.iov_base = nullptr;
        val.iov_len  = 0;
        return val;
    }

    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, MDBX_val>::type
    serialize_value(const T& value, SerializeScratch& sc) {
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(value.data()), value.size());
    }
    
    template <typename T>
    typename std::enable_if<
        has_value_type<T>::value &&
        std::is_trivially_copyable<typename T::value_type>::value &&
        (
            std::is_same<T, std::deque<typename T::value_type>>::value ||
            std::is_same<T, std::list<typename T::value_type>>::value ||
            std::is_same<T, std::set<typename T::value_type>>::value ||
            std::is_same<T, std::unordered_set<typename T::value_type>>::value
        ),
        MDBX_val>::type
    serialize_value(const T& container, SerializeScratch& sc) {
        using Elem = typename T::value_type;
        sc.bytes.resize(container.size() * sizeof(Elem));
        auto* out = reinterpret_cast<Elem*>(sc.bytes.data());
        std::copy(container.begin(), container.end(), out);
        return sc.view_bytes();
    }

    template<typename T>
    typename std::enable_if<
        has_value_type<T>::value &&
        std::is_same<T, std::vector<typename T::value_type>>::value &&
        std::is_trivially_copyable<typename T::value_type>::value,
        MDBX_val>::type
    serialize_value(const T& container, SerializeScratch& sc) {
        using Elem = typename T::value_type;
        sc.bytes.resize(container.size() * sizeof(Elem));
        std::memcpy(sc.bytes.data(),
                    container.data(),
                    sc.bytes.size());   
        return sc.view_bytes();
    }

    template<typename T>
    typename std::enable_if<has_to_bytes<T>::value, MDBX_val>::type
    serialize_value(const T& value, SerializeScratch& sc) {
        sc.bytes = value.to_bytes();
        return sc.view_bytes();
    }

    template<typename T>
    typename std::enable_if<
        !has_to_bytes<T>::value &&
        std::is_trivially_copyable<T>::value,
        MDBX_val>::type
    serialize_value(const T& value, SerializeScratch& sc) {
        (void)sc;
        return SerializeScratch::view(static_cast<const void*>(&value), sizeof(T));
    }

    template<typename T>
    typename std::enable_if<
            has_value_type<T>::value &&
            std::is_same<typename T::value_type, std::string>::value,
            MDBX_val>::type
    serialize_value(const T& container, SerializeScratch& sc) {
        sc.bytes.clear();
        for (const auto& str : container) {
            uint32_t len = static_cast<uint32_t>(str.size());
            sc.bytes.insert(sc.bytes.end(),
                          reinterpret_cast<const uint8_t*>(&len),
                          reinterpret_cast<const uint8_t*>(&len) + sizeof(uint32_t));
            sc.bytes.insert(sc.bytes.end(), str.begin(), str.end());
        }
        return sc.view_bytes();
    }
 
    // --- deserialize_value overloads ---
    
    template<typename T>
    typename std::enable_if<
        !has_value_type<T>::value &&
        !has_from_bytes<T>::value &&
        !std::is_same<T, std::string>::value &&
        !std::is_trivially_copyable<T>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        (void)val;
        static_assert(sizeof(T) == 0, "Unsupported type for deserialize_value");
        T out;
        return out;
    }

    template<typename T>
    typename std::enable_if<std::is_same<T, std::string>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        return std::string(static_cast<const char*>(val.iov_base), val.iov_len);
    }

    template<typename T>
    typename std::enable_if<
#       if __cplusplus >= 201703L
        std::is_same<T, std::vector<std::byte>>::value ||
#       endif
        std::is_same<T, std::vector<uint8_t>>::value ||
        std::is_same<T, std::vector<char>>::value ||
        std::is_same<T, std::vector<unsigned char>>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        const uint8_t* ptr = static_cast<const uint8_t*>(val.iov_base);
        return T(ptr, ptr + val.iov_len);
    }

    template<typename T>
    typename std::enable_if<
#       if __cplusplus >= 201703L
        std::is_same<T, std::deque<std::byte>>::value ||
#       endif
        std::is_same<T, std::deque<uint8_t>>::value ||
        std::is_same<T, std::deque<char>>::value ||
        std::is_same<T, std::deque<unsigned char>>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        const uint8_t* ptr = static_cast<const uint8_t*>(val.iov_base);
        return T(ptr, ptr + val.iov_len);
    }

    template<typename T>
    typename std::enable_if<
#       if __cplusplus >= 201703L
        std::is_same<T, std::list<std::byte>>::value ||
#       endif
        std::is_same<T, std::list<uint8_t>>::value ||
        std::is_same<T, std::list<char>>::value ||
        std::is_same<T, std::list<unsigned char>>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        const uint8_t* ptr = static_cast<const uint8_t*>(val.iov_base);
        return T(ptr, ptr + val.iov_len);
    }

    template<typename T>
    typename std::enable_if<
        has_value_type<T>::value &&
        std::is_same<T, std::vector<typename T::value_type>>::value &&
        std::is_trivially_copyable<typename T::value_type>::value &&
#       if __cplusplus >= 201703L
        !std::is_same<T, std::vector<std::byte>>::value &&
#       endif
        !std::is_same<T, std::vector<uint8_t>>::value &&
        !std::is_same<T, std::vector<char>>::value &&
        !std::is_same<T, std::vector<unsigned char>>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        typedef typename T::value_type Elem;
        if (val.iov_len % sizeof(Elem) != 0)
            throw std::runtime_error("deserialize_value: size not aligned");
        const size_t count = val.iov_len / sizeof(Elem);
        const Elem* data = static_cast<const Elem*>(val.iov_base);
        return T(data, data + count);
    }

    template<typename T>
    typename std::enable_if<
        (std::is_same<T, std::deque<typename T::value_type>>::value ||
         std::is_same<T, std::list<typename T::value_type>>::value) &&
        std::is_trivially_copyable<typename T::value_type>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        typedef typename T::value_type Elem;
        if (val.iov_len % sizeof(Elem) != 0) {
            throw std::runtime_error("deserialize_value: size not aligned");
        }
        const size_t count = val.iov_len / sizeof(Elem);
        const Elem* data = static_cast<const Elem*>(val.iov_base);
        return T(data, data + count);
    }

    template<typename T>
    typename std::enable_if<
        (
            std::is_same<T, std::set<typename T::value_type>>::value ||
            std::is_same<T, std::unordered_set<typename T::value_type>>::value
        ) &&
        std::is_trivially_copyable<typename T::value_type>::value,
        T>::type
    deserialize_value(const MDBX_val& val) {
        typedef typename T::value_type Elem;
        if (val.iov_len % sizeof(Elem) != 0)
            throw std::runtime_error("deserialize_value: size not aligned");
        const size_t count = val.iov_len / sizeof(Elem);
        const Elem* data = static_cast<const Elem*>(val.iov_base);
        return T(data, data + count);
    }

    template<typename T>
    typename std::enable_if<
        !has_from_bytes<T>::value && std::is_trivially_copyable<T>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        if (val.iov_len != sizeof(T)) {
            throw std::runtime_error("deserialize_value: size mismatch");
        }
        T out;
        std::memcpy(&out, val.iov_base, sizeof(T));
        return out;
    }

    template<typename T>
    typename std::enable_if<has_from_bytes<T>::value, T>::type
    deserialize_value(const MDBX_val& val) {
        return T::from_bytes(val.iov_base, val.iov_len);
    }

    template<typename T>
    typename std::enable_if<
            has_value_type<T>::value &&
            std::is_same<typename T::value_type, std::string>::value,
            T>::type
    deserialize_value(const MDBX_val& val) {
        const uint8_t* ptr = static_cast<const uint8_t*>(val.iov_base);
        const uint8_t* end = ptr + val.iov_len;
 
        T result;
        while (ptr + sizeof(uint32_t) <= end) {
            uint32_t len;
            std::memcpy(&len, ptr, sizeof(uint32_t));
            ptr += sizeof(uint32_t);
 
            if (ptr + len > end)
                throw std::runtime_error("deserialize_value: corrupted data (length overflow)");
 
            result.emplace_back(reinterpret_cast<const char*>(ptr), len);
            ptr += len;
        }
 
        if (ptr != end)
            throw std::runtime_error("deserialize_value: trailing data after deserialization");
 
        return result;
    }
    
    template<typename T>
    typename std::enable_if<
            std::is_same<T, std::set<std::string>>::value ||
            std::is_same<T, std::unordered_set<std::string>>::value,
            T>::type
    deserialize_value(const MDBX_val& val) {
        const uint8_t* ptr = static_cast<const uint8_t*>(val.iov_base);
        const uint8_t* end = ptr + val.iov_len;
        T result;
 
        while (ptr + sizeof(uint32_t) <= end) {
            uint32_t len;
            std::memcpy(&len, ptr, sizeof(uint32_t));
            ptr += sizeof(uint32_t);
 
            if (ptr + len > end)
                throw std::runtime_error("deserialize_value: corrupted data (length overflow)");
 
            result.insert(std::string(reinterpret_cast<const char*>(ptr), len));
            ptr += len;
        }
 
        if (ptr != end)
            throw std::runtime_error("deserialize_value: trailing data after deserialization");
 
        return result;
    }
 
}; // namespace mdbxc

 
#undef MDBXC_NODISCARD
 
#endif // _MDBX_CONTAINERS_UTILS_HPP_INCLUDED