range_types.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/postgres/io/range_types.hpp
/// @brief Ranges I/O support
/// @ingroup userver_postgres_parse_and_format
 
#include <optional>
#include <ostream>
 
#include <fmt/format.h>
 
#include <userver/storages/postgres/exceptions.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/field_buffer.hpp>
#include <userver/storages/postgres/io/traits.hpp>
#include <userver/storages/postgres/io/type_mapping.hpp>
#include <userver/storages/postgres/io/type_traits.hpp>
#include <userver/storages/postgres/io/user_types.hpp>
 
#include <userver/utils/assert.hpp>
#include <userver/utils/flags.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres {
 
struct UnboundedType {};
constexpr UnboundedType kUnbounded{};
 
enum class RangeBound {
    kNone = 0x00,
    kLower = 0x01,
    kUpper = 0x02,
    kBoth = kLower | kUpper,
};
 
using RangeBounds = USERVER_NAMESPACE::utils::Flags<RangeBound>;
 
template <typename T>
class Range {
    static constexpr bool kNothrowValueCtor = std::is_nothrow_default_constructible_v<T>;
    static constexpr bool kNothrowValueCopy = std::is_nothrow_copy_constructible_v<T>;
    static constexpr bool kNothrowValueMove = std::is_nothrow_move_constructible_v<T>;
    static constexpr bool kIsDiscreteValue = std::is_integral_v<T>;
 
public:
    using OptionalValue = std::optional<T>;
 
    /// Empty range
    Range() = default;
 
    /// Unbounded range
    Range(UnboundedType, UnboundedType) noexcept : data_{RangeData{}} {}
 
    /// Bounded range
    template <typename U>
    requires std::is_convertible_v<std::decay_t<U>, T>
    Range(U&& lower, U&& upper, RangeBounds bounds = RangeBound::kLower);
 
    /// Range with a lower bound
    template <typename U>
    requires std::is_convertible_v<std::decay_t<U>, T>
    Range(U&& lower, UnboundedType ub, RangeBounds bounds = RangeBound::kLower) noexcept(kNothrowValueCopy);
 
    /// Range with an upper bound
    template <typename U>
    requires std::is_convertible_v<std::decay_t<U>, T>
    Range(UnboundedType ub, U&& upper, RangeBounds bounds = RangeBound::kNone) noexcept(kNothrowValueCopy);
 
    Range(const OptionalValue& lower, const OptionalValue& upper, RangeBounds bounds);
 
    /// Convert from a range of different type.
    ///
    /// Intentionally implicit
    template <typename U>
    requires std::is_convertible_v<U, T>
    Range(const Range<U>& rhs);
 
    bool operator==(const Range& rhs) const;
 
    bool Empty() const { return !data_; }
 
    /// Make the range empty
    void Clear() { data_.reset(); }
 
    bool HasLowerBound() const { return !!data_ && data_->HasBound(RangeBound::kLower); }
    bool HasUpperBound() const { return !!data_ && data_->HasBound(RangeBound::kUpper); }
 
    /// Get the lower bound.
    const OptionalValue& GetLowerBound() const {
        if (!!data_) {
            return data_->GetOptionalValue(RangeBound::kLower);
        }
        return kNoValue;
    }
 
    /// Get the upper bound.
    const OptionalValue& GetUpperBound() const {
        if (!!data_) {
            return data_->GetOptionalValue(RangeBound::kUpper);
        }
        return kNoValue;
    }
 
    bool IsLowerBoundIncluded() const { return !!data_ && data_->IsBoundIncluded(RangeBound::kLower); }
    bool IsUpperBoundIncluded() const { return !!data_ && data_->IsBoundIncluded(RangeBound::kUpper); }
 
private:
    template <typename U>
    friend class Range;
 
    struct RangeData {
        // Unbounded range
        RangeData() noexcept = default;
 
        template <typename U>
        RangeData(U&& lower, U&& upper, RangeBounds bounds)
            : RangeData{OptionalValue{std::forward<U>(lower)}, OptionalValue{std::forward<U>(upper)}, bounds}
        {}
 
        template <typename U>
        RangeData(U&& lower, UnboundedType, RangeBounds bounds) noexcept(kNothrowValueCopy)
            : RangeData{OptionalValue{std::forward<U>(lower)}, OptionalValue{}, bounds}
        {}
 
        template <typename U>
        RangeData(UnboundedType, U&& upper, RangeBounds bounds) noexcept(kNothrowValueCopy)
            : RangeData{OptionalValue{}, OptionalValue{std::forward<U>(upper)}, bounds}
        {}
 
        RangeData(OptionalValue low, OptionalValue up, RangeBounds bounds)
            : bounds{bounds},
              lower{std::move(low)},
              upper{std::move(up)}
        {
            if (lower && upper && *upper < *lower) {
                throw LogicError("Range lower bound is greater than upper");
            }
        }
 
        bool operator==(const RangeData& rhs) const {
            return BoundEqual(rhs, RangeBound::kLower) && BoundEqual(rhs, RangeBound::kUpper);
        }
 
        bool HasBound(RangeBounds side) const;
 
        bool IsBoundIncluded(RangeBounds side) const { return HasBound(side) && (bounds & side); }
 
        bool BoundEqual(const RangeData& rhs, RangeBounds side) const;
 
        // Using this function without checking is ub
        const T& GetBoundValue(RangeBounds side) const {
            if (side == RangeBound::kLower) {
                return *lower;
            }
            UASSERT_MSG(side == RangeBound::kUpper, "Invalid bounds side argument value");
            return *upper;
        }
 
        const OptionalValue& GetOptionalValue(RangeBounds side) const {
            if (side == RangeBound::kLower) {
                return lower;
            }
            UASSERT_MSG(side == RangeBound::kUpper, "Invalid bounds side argument value");
            return upper;
        }
 
        RangeBounds bounds = RangeBound::kNone;
        OptionalValue lower;
        OptionalValue upper;
    };
 
    template <typename U>
    static OptionalValue ConvertBound(const std::optional<U>& rhs) {
        if (!rhs) {
            return OptionalValue{};
        }
        return OptionalValue{*rhs};
    }
 
    template <typename U>
    static std::optional<RangeData> ConvertData(const Range<U>& rhs) {
        if (!rhs.data_) {
            return {};
        }
        return RangeData{ConvertBound(rhs.data_->lower), ConvertBound(rhs.data_->upper), rhs.data_->bounds};
    }
 
    std::optional<RangeData> data_;
 
    static const inline OptionalValue kNoValue{};
};
 
template <typename T>
auto MakeRange(T&& lower, T&& upper, RangeBounds bounds = RangeBound::kLower) {
    using ElementType = std::decay_t<T>;
    return Range<ElementType>{std::forward<T>(lower), std::forward<T>(upper), bounds};
}
 
template <typename T>
auto MakeRange(T&& lower, UnboundedType, RangeBounds bounds = RangeBound::kLower) {
    using ElementType = std::decay_t<T>;
    return Range<ElementType>{std::forward<T>(lower), kUnbounded, bounds};
}
 
template <typename T>
auto MakeRange(UnboundedType, T&& upper, RangeBounds bounds = RangeBound::kNone) {
    using ElementType = std::decay_t<T>;
    return Range<ElementType>{kUnbounded, std::forward<T>(upper), bounds};
}
 
using IntegerRange = Range<Integer>;
using BigintRange = Range<Bigint>;
 
template <typename T>
class BoundedRange {
    static constexpr bool kNothrowValueCtor = std::is_nothrow_default_constructible_v<T>;
 
public:
    using ValueType = T;
 
    BoundedRange() noexcept(kNothrowValueCtor);
 
    template <typename U>
    requires std::is_convertible_v<std::decay_t<U>, T>
    BoundedRange(U&& lower, U&& upper, RangeBounds bounds = RangeBound::kLower);
 
    template <typename U>
    explicit BoundedRange(Range<U>&&);
 
    bool operator==(const BoundedRange& rhs) const;
 
    const ValueType& GetLowerBound() const { return *value_.GetLowerBound(); }
    bool IsLowerBoundIncluded() const { return value_.IsLowerBoundIncluded(); }
 
    const ValueType& GetUpperBound() const { return *value_.GetUpperBound(); }
    bool IsUpperBoundIncluded() const { return value_.IsUpperBoundIncluded(); }
 
    const Range<T>& GetUnboundedRange() const { return value_; }
 
    // TODO Intersection and containment test functions on user demand
private:
    Range<T> value_;
};
 
using BoundedIntegerRange = BoundedRange<Integer>;
using BoundedBigintRange = BoundedRange<Bigint>;
 
}  // namespace storages::postgres
 
namespace storages::postgres::io {
 
namespace detail {
 
enum class RangeFlag {
    kNone = 0x00,
    kEmpty = 0x01,
    kLowerBoundInclusive = 0x02,
    kUpperBoundInclusive = 0x04,
    kLowerBoundInfinity = 0x08,
    kUpperBoundInfinity = 0x10,
    kLowerBoundNull = 0x20,
    kUpperBoundNull = 0x40,
    kContainEmpty = 0x80,
};
 
using RangeFlags = USERVER_NAMESPACE::utils::Flags<RangeFlag>;
 
constexpr bool HasLowerBound(RangeFlags flags) {
    return !(flags & RangeFlags{RangeFlag::kEmpty, RangeFlag::kLowerBoundNull, RangeFlag::kLowerBoundInfinity});
}
 
constexpr bool HasUpperBound(RangeFlags flags) {
    return !(flags & RangeFlags{RangeFlag::kEmpty, RangeFlag::kUpperBoundNull, RangeFlag::kUpperBoundInfinity});
}
 
template <typename T>
struct RangeBinaryParser : BufferParserBase<Range<T>> {
    using BaseType = BufferParserBase<Range<T>>;
    using ValueType = typename BaseType::ValueType;
    using ElementType = T;
    using ElementParser = typename traits::IO<ElementType>::ParserType;
 
    static constexpr BufferCategory element_buffer_category = traits::kParserBufferCategory<ElementParser>;
 
    using BaseType::BaseType;
 
    void operator()(FieldBuffer buffer, const TypeBufferCategory& categories) {
        char wire_range_flags{0};
 
        buffer.Read(wire_range_flags, BufferCategory::kPlainBuffer);
        const RangeFlags range_flags(static_cast<RangeFlag>(wire_range_flags));
 
        ValueType wire_value;
        if (range_flags != RangeFlag::kEmpty) {
            RangeBounds bounds = RangeBound::kNone;
            typename ValueType::OptionalValue lower;
            typename ValueType::OptionalValue upper;
            if (HasLowerBound(range_flags)) {
                if (range_flags & RangeFlag::kLowerBoundInclusive) {
                    bounds |= RangeBound::kLower;
                }
                T tmp;
                buffer.ReadRaw(tmp, categories, element_buffer_category);
                lower = tmp;
            }
            if (HasUpperBound(range_flags)) {
                if (range_flags & RangeFlag::kUpperBoundInclusive) {
                    bounds |= RangeBound::kUpper;
                }
                T tmp;
                buffer.ReadRaw(tmp, categories, element_buffer_category);
                upper = tmp;
            }
            wire_value = ValueType{lower, upper, bounds};
        }
        this->value = wire_value;
    }
};
 
template <typename T>
struct RangeBinaryFormatter : BufferFormatterBase<Range<T>> {
    using BaseType = BufferFormatterBase<Range<T>>;
 
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        RangeFlags range_flags;
        if (this->value.Empty()) {
            range_flags |= RangeFlag::kEmpty;
        } else {
            // Mark lower/upper bound
            if (!this->value.HasLowerBound()) {
                range_flags |= RangeFlag::kLowerBoundInfinity;
            } else if (this->value.IsLowerBoundIncluded()) {
                range_flags |= RangeFlag::kLowerBoundInclusive;
            }
            if (!this->value.HasUpperBound()) {
                range_flags |= RangeFlag::kUpperBoundInfinity;
            } else if (this->value.IsUpperBoundIncluded()) {
                range_flags |= RangeFlag::kUpperBoundInclusive;
            }
        }
        const char wire_range_flags = static_cast<char>(range_flags.GetValue());
        io::WriteBuffer(types, buffer, wire_range_flags);
        if (!this->value.Empty()) {
            // Write lower/upper bounds
            if (this->value.HasLowerBound()) {
                io::WriteRawBinary(types, buffer, this->value.GetLowerBound());
            }
            if (this->value.HasUpperBound()) {
                io::WriteRawBinary(types, buffer, this->value.GetUpperBound());
            }
        }
    }
};
 
template <typename T>
struct BoundedRangeBinaryParser : BufferParserBase<BoundedRange<T>> {
    using BaseType = BufferParserBase<BoundedRange<T>>;
    using ValueType = typename BaseType::ValueType;
 
    using BaseType::BaseType;
 
    void operator()(FieldBuffer buffer, const TypeBufferCategory& categories) {
        Range<T> tmp;
        io::ReadBuffer(buffer, tmp, categories);
        this->value = ValueType{std::move(tmp)};
    }
};
 
template <typename T>
struct BoundedRangeBinaryFormatter : BufferFormatterBase<BoundedRange<T>> {
    using BaseType = BufferFormatterBase<BoundedRange<T>>;
 
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        io::WriteBuffer(types, buffer, this->value.GetUnboundedRange());
    }
};
 
}  // namespace detail
 
namespace traits {
 
template <HasParser T>
struct Input<Range<T>> {
    using type = io::detail::RangeBinaryParser<T>;
};
 
template <typename T>
struct ParserBufferCategory<io::detail::RangeBinaryParser<T>>
    : std::integral_constant<BufferCategory, BufferCategory::kRangeBuffer> {};
 
template <HasFormatter T>
struct Output<Range<T>> {
    using type = io::detail::RangeBinaryFormatter<T>;
};
 
template <HasParser T>
struct Input<BoundedRange<T>> {
    using type = io::detail::BoundedRangeBinaryParser<T>;
};
 
template <typename T>
struct ParserBufferCategory<io::detail::BoundedRangeBinaryParser<T>>
    : std::integral_constant<BufferCategory, BufferCategory::kRangeBuffer> {};
 
template <HasFormatter T>
struct Output<BoundedRange<T>> {
    using type = io::detail::BoundedRangeBinaryFormatter<T>;
};
 
}  // namespace traits
 
template <>
struct CppToSystemPg<IntegerRange> : PredefinedOid<PredefinedOids::kInt4Range> {};
template <>
struct CppToSystemPg<BoundedIntegerRange> : PredefinedOid<PredefinedOids::kInt4Range> {};
template <>
struct CppToSystemPg<BigintRange> : PredefinedOid<PredefinedOids::kInt8Range> {};
template <>
struct CppToSystemPg<BoundedBigintRange> : PredefinedOid<PredefinedOids::kInt8Range> {};
 
}  // namespace storages::postgres::io
 
namespace storages::postgres {
 
template <typename T>
template <typename U>
requires std::is_convertible_v<std::decay_t<U>, T>
Range<T>::Range(U&& lower, U&& upper, RangeBounds bounds)
    : data_{RangeData{std::forward<U>(lower), std::forward<U>(upper), bounds}}
{
    if (data_->lower == data_->upper && bounds != RangeBound::kBoth) {
        // this will make an empty range
        data_.reset();
    }
}
 
template <typename T>
template <typename U>
requires std::is_convertible_v<std::decay_t<U>, T>
Range<T>::Range(U&& lower, UnboundedType ub, RangeBounds bounds) noexcept(kNothrowValueCopy)
    : data_{RangeData{std::forward<U>(lower), ub, bounds}}
{}
 
template <typename T>
template <typename U>
requires std::is_convertible_v<std::decay_t<U>, T>
Range<T>::Range(UnboundedType ub, U&& upper, RangeBounds bounds) noexcept(kNothrowValueCopy)
    : data_{RangeData{ub, std::forward<U>(upper), bounds}}
{}
 
template <typename T>
Range<T>::Range(const OptionalValue& lower, const OptionalValue& upper, RangeBounds bounds)
    : data_{RangeData{lower, upper, bounds}}
{}
 
template <typename T>
template <typename U>
requires std::is_convertible_v<U, T>
Range<T>::Range(const Range<U>& rhs)
    : data_{ConvertData(rhs)}
{}
 
template <typename T>
bool Range<T>::operator==(const Range& rhs) const {
    return (Empty() && rhs.Empty()) || (data_ == rhs.data_);
}
 
template <typename T>
std::ostream& operator<<(std::ostream& os, const Range<T>& val) {
    if (val.Empty()) {
        return os << "empty";
    }
    if (val.HasLowerBound() && val.IsLowerBoundIncluded()) {
        os << '[';
    } else {
        os << '(';
    }
    if (val.HasLowerBound()) {
        os << *val.GetLowerBound();
    } else {
        os << "-inf";
    }
    os << ", ";
    if (val.HasUpperBound()) {
        os << *val.GetUpperBound();
    } else {
        os << "inf";
    }
    if (val.HasUpperBound() && val.IsUpperBoundIncluded()) {
        os << ']';
    } else {
        os << ')';
    }
    return os;
}
 
template <typename T>
bool Range<T>::RangeData::HasBound(RangeBounds side) const {
    if (side == RangeBound::kLower) {
        return !!lower;
    }
    if (side == RangeBound::kUpper) {
        return !!upper;
    }
    return false;
}
 
template <typename T>
bool Range<T>::RangeData::BoundEqual(const RangeData& rhs, RangeBounds side) const {
    const bool has_bound = HasBound(side);
    if (has_bound != rhs.HasBound(side)) {
        return false;
    }
    if (!has_bound) {  // both are unbounded
        return true;
    }
    const auto& lval = GetBoundValue(side);
    const auto& rval = rhs.GetBoundValue(side);
    if ((bounds & side) == (rhs.bounds & side)) {
        // same include
        return lval == rval;
    }
    if constexpr (kIsDiscreteValue) {
        T diff = (side == RangeBound::kLower ? 1 : -1);
        if (IsBoundIncluded(side)) {
            return lval == rval + diff;
        } else {
            return lval + diff == rval;
        }
    }
    return false;
}
 
template <typename T>
BoundedRange<T>::BoundedRange() noexcept(kNothrowValueCtor)
    : value_{T{}, T{}, RangeBound::kBoth}
{}
 
template <typename T>
template <typename U>
requires std::is_convertible_v<std::decay_t<U>, T>
BoundedRange<T>::BoundedRange(U&& lower, U&& upper, RangeBounds bounds)
    : value_{std::forward<U>(lower), std::forward<U>(upper), bounds}
{}
 
template <typename T>
template <typename U>
BoundedRange<T>::BoundedRange(Range<U>&& rhs)
    : value_{std::move(rhs)}
{
    if (value_.Empty()) {
        throw BoundedRangeError{"empty range"};
    }
    if (!value_.HasLowerBound()) {
        throw BoundedRangeError{"lower bound is missing"};
    }
    if (!value_.HasUpperBound()) {
        throw BoundedRangeError{"upper bound is missing"};
    }
}
 
template <typename T>
bool BoundedRange<T>::operator==(const BoundedRange& rhs) const {
    return value_ == rhs.value_;
}
 
template <typename T>
std::ostream& operator<<(std::ostream& os, const BoundedRange<T>& val) {
    return os << val.GetUnboundedRange();
}
}  // namespace storages::postgres
 
// TODO fmt::format specializations on user demand
 
USERVER_NAMESPACE_END