bitstring.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/postgres/io/bitstring.hpp
/// @brief storages::postgres::BitString I/O support
/// @ingroup userver_postgres_parse_and_format
 
#include <bitset>
#include <vector>
 
#include <userver/storages/postgres/exceptions.hpp>
#include <userver/storages/postgres/io/buffer_io.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/type_mapping.hpp>
 
#include <userver/utils/flags.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres {
 
namespace io::traits {
 
template <typename BitContainer>
struct IsBitStringCompatible : std::is_integral<BitContainer> {};
 
template <typename Enum>
struct IsBitStringCompatible<USERVER_NAMESPACE::utils::Flags<Enum>> : std::true_type {};
 
template <std::size_t N>
struct IsBitStringCompatible<std::bitset<N>> : std::true_type {};
 
template <std::size_t N>
struct IsBitStringCompatible<std::array<bool, N>> : std::true_type {};
 
template <typename T>
inline constexpr bool kIsBitStringCompatible = IsBitStringCompatible<T>::value;
 
template <typename BitContainer, typename Enable = void>
struct BitContainerTraits;
 
template <typename BitContainer>
struct BitContainerTraits<BitContainer, std::enable_if_t<std::is_integral_v<BitContainer>>> {
    static bool TestBit(const BitContainer& bits, std::uint8_t i) { return bits & (1ull << i); }
    static void SetBit(BitContainer& bits, std::uint8_t i) { bits |= (1ull << i); }
    static constexpr std::size_t BitCount() noexcept { return sizeof(BitContainer) * 8; }
    static void Reset(BitContainer& bits) noexcept { bits = 0; }
};
 
template <std::size_t N>
struct BitContainerTraits<std::array<bool, N>> {
    static_assert(N > 0, "Length for bit container must be at least 1");
    using BitContainer = std::array<bool, N>;
    static bool TestBit(const BitContainer& bits, std::uint8_t i) { return bits[i]; }
    static void SetBit(BitContainer& bits, std::uint8_t i) { bits[i] = true; }
    static constexpr std::size_t BitCount() noexcept { return N; }
    static void Reset(BitContainer& bits) noexcept { bits.fill(false); }
};
 
template <std::size_t N>
struct BitContainerTraits<std::bitset<N>> {
    static_assert(N > 0, "Length for bit container must be at least 1");
    using BitContainer = std::bitset<N>;
    static bool TestBit(const BitContainer& bits, std::uint8_t i) { return bits.test(i); }
    static void SetBit(BitContainer& bits, std::uint8_t i) { bits.set(i); }
    static constexpr std::size_t BitCount() noexcept { return N; }
    static void Reset(BitContainer& bits) noexcept { bits.reset(); }
};
 
}  // namespace io::traits
 
enum class BitStringType { kBit, kBitVarying };
 
namespace detail {
 
enum class BitContainerInterface { kCommon, kFlags };
 
template <typename BitContainerRef, BitContainerInterface, BitStringType>
struct BitStringRefWrapper {
    static_assert(std::is_reference<BitContainerRef>::value, "The container must be passed by reference");
 
    using BitContainer = std::decay_t<BitContainerRef>;
    static_assert(
        io::traits::kIsBitStringCompatible<BitContainer>,
        "This C++ type cannot be used with PostgreSQL 'bit' and 'bit "
        "varying' data type"
    );
 
    BitContainerRef bits;
};
 
}  // namespace detail
 
template <typename BitContainer, BitStringType>
struct BitStringWrapper {
    static_assert(!std::is_reference<BitContainer>::value, "The container must not be passed by reference");
 
    static_assert(
        io::traits::kIsBitStringCompatible<BitContainer>,
        "This C++ type cannot be used with PostgreSQL 'bit' and 'bit "
        "varying' data type"
    );
 
    BitContainer bits{};
};
 
template <BitStringType kBitStringType, typename BitContainer>
constexpr detail::BitStringRefWrapper<const BitContainer&, detail::BitContainerInterface::kCommon, kBitStringType>
BitString(const BitContainer& bits) {
    return {bits};
}
 
template <BitStringType kBitStringType, typename BitContainer>
constexpr detail::BitStringRefWrapper<BitContainer&, detail::BitContainerInterface::kCommon, kBitStringType> BitString(
    BitContainer& bits
) {
    return {bits};
}
 
template <BitStringType kBitStringType, typename Enum>
constexpr detail::BitStringRefWrapper<
    const USERVER_NAMESPACE::utils::Flags<Enum>&,
    detail::BitContainerInterface::kFlags,
    kBitStringType>
BitString(const USERVER_NAMESPACE::utils::Flags<Enum>& bits) {
    return {bits};
}
 
template <BitStringType kBitStringType, typename Enum>
constexpr detail::BitStringRefWrapper<
    USERVER_NAMESPACE::utils::Flags<Enum>&,
    detail::BitContainerInterface::kFlags,
    kBitStringType>
BitString(USERVER_NAMESPACE::utils::Flags<Enum>& bits) {
    return {bits};
}
 
template <typename BitContainer>
constexpr auto Varbit(BitContainer&& bits) {
    return BitString<BitStringType::kBitVarying>(std::forward<BitContainer>(bits));
}
 
template <typename BitContainer>
constexpr auto Bit(BitContainer&& bits) {
    return BitString<BitStringType::kBit>(std::forward<BitContainer>(bits));
}
 
namespace io {
 
template <typename BitContainerRef, BitStringType kBitStringType>
struct BufferParser<postgres::detail::BitStringRefWrapper<
    BitContainerRef,
    postgres::detail::BitContainerInterface::kCommon,
    kBitStringType>>
    : detail::BufferParserBase<postgres::detail::BitStringRefWrapper<
          BitContainerRef,
          postgres::detail::BitContainerInterface::kCommon,
          kBitStringType>&&> {
    using BitContainer = std::decay_t<BitContainerRef>;
    using BaseType = detail::BufferParserBase<postgres::detail::BitStringRefWrapper<
        BitContainerRef,
        postgres::detail::BitContainerInterface::kCommon,
        kBitStringType>&&>;
    using BaseType::BaseType;
 
    void operator()(FieldBuffer buffer) {
        Integer bit_count{0};
        buffer.Read(bit_count, BufferCategory::kPlainBuffer);
        if (static_cast<std::size_t>((bit_count + 7) / 8) > buffer.length) {
            throw InvalidBitStringRepresentation{};
        }
 
        auto& bits = this->value.bits;
        if (const Integer target_bit_count = io::traits::BitContainerTraits<BitContainer>::BitCount();
            target_bit_count < bit_count)
        {
            throw BitStringOverflow(bit_count, target_bit_count);
        }
 
        // buffer contains a zero-padded bitstring, most significant bit first
        io::traits::BitContainerTraits<BitContainer>::Reset(bits);
        for (Integer i = 0; i < bit_count; ++i) {
            const auto* byte_cptr = buffer.buffer + (i / 8);
            if ((*byte_cptr) & (0x80 >> (i % 8))) {
                io::traits::BitContainerTraits<BitContainer>::SetBit(bits, bit_count - i - 1);
            }
        }
    }
};
 
template <typename BitContainerRef, BitStringType kBitStringType>
struct BufferParser<postgres::detail::BitStringRefWrapper<
    BitContainerRef,
    postgres::detail::BitContainerInterface::kFlags,
    kBitStringType>>
    : detail::BufferParserBase<postgres::detail::BitStringRefWrapper<
          BitContainerRef,
          postgres::detail::BitContainerInterface::kFlags,
          kBitStringType>&&> {
    using BitContainer = std::decay_t<BitContainerRef>;
    using BaseType = detail::BufferParserBase<postgres::detail::BitStringRefWrapper<
        BitContainerRef,
        postgres::detail::BitContainerInterface::kFlags,
        kBitStringType>&&>;
    using BaseType::BaseType;
 
    void operator()(FieldBuffer buffer) {
        typename BitContainer::ValueType bits{0};
        ReadBuffer(buffer, BitString<kBitStringType>(bits));
        this->value.bits.SetValue(bits);
    }
};
 
template <typename BitContainer, BitStringType kBitStringType>
struct BufferParser<postgres::BitStringWrapper<BitContainer, kBitStringType>>
    : detail::BufferParserBase<postgres::BitStringWrapper<BitContainer, kBitStringType>> {
    using BaseType = detail::BufferParserBase<postgres::BitStringWrapper<BitContainer, kBitStringType>>;
    using BaseType::BaseType;
 
    void operator()(const FieldBuffer& buffer) { ReadBuffer(buffer, BitString<kBitStringType>(this->value.bits)); }
};
 
template <std::size_t N>
struct BufferParser<std::bitset<N>> : detail::BufferParserBase<std::bitset<N>> {
    using BaseType = detail::BufferParserBase<std::bitset<N>>;
    using BaseType::BaseType;
 
    void operator()(const FieldBuffer& buffer) { ReadBuffer(buffer, Varbit(this->value)); }
};
 
template <typename BitContainerRef, BitStringType kBitStringType>
struct BufferFormatter<postgres::detail::BitStringRefWrapper<
    BitContainerRef,
    postgres::detail::BitContainerInterface::kCommon,
    kBitStringType>>
    : detail::BufferFormatterBase<postgres::detail::BitStringRefWrapper<
          BitContainerRef,
          postgres::detail::BitContainerInterface::kCommon,
          kBitStringType>> {
    using BitContainer = std::decay_t<BitContainerRef>;
    using BaseType = detail::BufferFormatterBase<postgres::detail::BitStringRefWrapper<
        BitContainerRef,
        postgres::detail::BitContainerInterface::kCommon,
        kBitStringType>>;
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        // convert bitcontainer to bytes and write into buffer,
        // from most to least significant
        const auto& bits = this->value.bits;
        constexpr auto bit_count = io::traits::BitContainerTraits<BitContainer>::BitCount();
 
        std::array<std::uint8_t, (bit_count + 7) / 8> data{};
        for (std::size_t i = 0; i < bit_count; ++i) {
            data[i / 8] |=
                static_cast<std::uint8_t>(io::traits::BitContainerTraits<BitContainer>::TestBit(bits, bit_count - i - 1)
                )
                << (7 - i % 8);
        }
 
        buffer.reserve(buffer.size() + sizeof(Integer) + data.size());
        WriteBuffer(types, buffer, static_cast<Integer>(bit_count));
        buffer.insert(buffer.end(), data.begin(), data.end());
    }
};
 
template <typename BitContainerRef, BitStringType kBitStringType>
struct BufferFormatter<postgres::detail::BitStringRefWrapper<
    BitContainerRef,
    postgres::detail::BitContainerInterface::kFlags,
    kBitStringType>>
    : detail::BufferFormatterBase<postgres::detail::BitStringRefWrapper<
          BitContainerRef,
          postgres::detail::BitContainerInterface::kFlags,
          kBitStringType>> {
    using BitContainer = std::decay_t<BitContainerRef>;
    using BaseType = detail::BufferFormatterBase<postgres::detail::BitStringRefWrapper<
        BitContainerRef,
        postgres::detail::BitContainerInterface::kFlags,
        kBitStringType>>;
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        WriteBuffer(types, buffer, BitString<kBitStringType>(this->value.bits.GetValue()));
    }
};
 
template <typename BitContainer, BitStringType kBitStringType>
struct BufferFormatter<postgres::BitStringWrapper<BitContainer, kBitStringType>>
    : detail::BufferFormatterBase<postgres::BitStringWrapper<BitContainer, kBitStringType>> {
    using BaseType = detail::BufferFormatterBase<postgres::BitStringWrapper<BitContainer, kBitStringType>>;
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        WriteBuffer(types, buffer, BitString<kBitStringType>(this->value.bits));
    }
};
 
// std::bitset is saved as bit varying on default
 
template <std::size_t N>
struct BufferFormatter<std::bitset<N>> : detail::BufferFormatterBase<std::bitset<N>> {
    using BitContainer = std::bitset<N>;
    using BaseType = detail::BufferFormatterBase<std::bitset<N>>;
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        WriteBuffer(types, buffer, Varbit(this->value));
    }
};
 
template <typename BitContainer, postgres::detail::BitContainerInterface ContainerInterface>
struct CppToSystemPg<
    postgres::detail::BitStringRefWrapper<BitContainer, ContainerInterface, postgres::BitStringType::kBitVarying>>
    : PredefinedOid<PredefinedOids::kVarbit> {};
template <typename BitContainer>
struct CppToSystemPg<postgres::BitStringWrapper<BitContainer, postgres::BitStringType::kBitVarying>>
    : PredefinedOid<PredefinedOids::kVarbit> {};
 
template <typename BitContainer, postgres::detail::BitContainerInterface ContainerInterface>
struct CppToSystemPg<
    postgres::detail::BitStringRefWrapper<BitContainer, ContainerInterface, postgres::BitStringType::kBit>>
    : PredefinedOid<PredefinedOids::kBit> {};
template <typename BitContainer>
struct CppToSystemPg<postgres::BitStringWrapper<BitContainer, postgres::BitStringType::kBit>>
    : PredefinedOid<PredefinedOids::kBit> {};
 
template <std::size_t N>
struct CppToSystemPg<std::bitset<N>> : PredefinedOid<PredefinedOids::kVarbit> {};
 
}  // namespace io
}  // namespace storages::postgres
 
USERVER_NAMESPACE_END