types.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/bson/types.hpp
/// @brief BSON-specific types
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <bson/bson.h>
#include <fmt/core.h>
 
#include <userver/formats/common/path.hpp>
#include <userver/logging/log_helper_fwd.hpp>
#include <userver/utils/fmt_compat.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::bson {
namespace impl {
// https://jira.mongodb.org/browse/CDRIVER-3378
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
using BsonHolder = std::shared_ptr<const bson_t>;
#pragma GCC diagnostic pop
 
class ValueImpl;
using ValueImplPtr = std::shared_ptr<ValueImpl>;
 
using ParsedArray = std::vector<ValueImplPtr>;
using ParsedDocument = std::unordered_map<std::string, ValueImplPtr>;
}  // namespace impl
 
using formats::common::Path;
 
inline constexpr auto kNull = nullptr;
 
/// BSON ObjectId
class Oid {
public:
    /// Generates a new id
    Oid();
 
    /// Constructor from hex-encoded form, zero terminator is not required
    explicit Oid(std::string_view hex_encoded);
 
    /// Creates a minimal Oid with specified time point up to a second precision
    ///
    /// @throws formats::bson::BsonException if `time` is too big to be stored in
    /// ObjectId without narrowing.
    static Oid MakeMinimalFor(std::chrono::system_clock::time_point time);
 
    /// @cond
    /// Constructor from native type
    /* implicit */ Oid(const bson_oid_t&);
    /// @endcond
 
    /// Returns hex-encoded value
    std::string ToString() const;
 
    /// @name Raw value access
    /// @{
    const uint8_t* Data() const;
 
    constexpr static size_t Size() { return 12; }
    /// @}
 
    /// Returns stored unix timestamp
    time_t GetTimestamp() const;
 
    /// Returns stored time point
    std::chrono::system_clock::time_point GetTimePoint() const;
 
    /// @cond
    /// Native type access, internal use only
    const bson_oid_t* GetNative() const;
    /// @endcond
 
    bool operator==(const Oid&) const;
    bool operator!=(const Oid&) const;
    bool operator<(const Oid&) const;
    bool operator>(const Oid&) const;
    bool operator<=(const Oid&) const;
    bool operator>=(const Oid&) const;
 
private:
    friend struct std::hash<Oid>;
 
    bson_oid_t oid_;
};
 
logging::LogHelper& operator<<(logging::LogHelper& lh, const Oid& value);
 
/// BSON Binary
class Binary {
public:
    /// Constructor from a string storage
    explicit Binary(std::string data) : data_(std::move(data)) {}
 
    /// @name Raw data access
    /// @{
    const std::string& ToString() const& { return data_; }
    std::string&& ToString() && { return std::move(data_); }
 
    const uint8_t* Data() const { return reinterpret_cast<const uint8_t*>(data_.data()); }
    size_t Size() const { return data_.size(); }
    /// @}
 
    bool operator==(const Binary& rhs) const { return data_ == rhs.data_; }
    bool operator!=(const Binary& rhs) const { return data_ != rhs.data_; }
    bool operator<(const Binary& rhs) const { return data_ < rhs.data_; }
    bool operator>(const Binary& rhs) const { return data_ > rhs.data_; }
    bool operator<=(const Binary& rhs) const { return data_ <= rhs.data_; }
    bool operator>=(const Binary& rhs) const { return data_ >= rhs.data_; }
 
private:
    friend struct std::hash<Binary>;
 
    std::string data_;
};
 
/// @brief BSON Decimal128
/// @see
/// https://github.com/mongodb/specifications/blob/master/source/bson-decimal128/decimal128.rst
class Decimal128 {
public:
    /// Constructor from a string form
    explicit Decimal128(const std::string& value);
 
    /// @cond
    /// Constructor from native type
    /* implicit */ Decimal128(const bson_decimal128_t&);
    /// @endcond
 
    /// Returns string form
    std::string ToString() const;
 
    /// Returns an infinite value
    static Decimal128 Infinity();
 
    /// Returns a not-a-number value
    static Decimal128 NaN();
 
    /// @cond
    /// Native type access, internal use only
    const bson_decimal128_t* GetNative() const;
    /// @endcond
 
    bool operator==(const Decimal128&) const;
    bool operator!=(const Decimal128&) const;
 
private:
    bson_decimal128_t decimal_;
};
 
/// BSON MinKey
class MinKey {};
 
/// BSON MaxKey
class MaxKey {};
 
/// @brief BSON Timestamp
/// @warning Do not use this type for time point representation!
/// It is very limited and intended for internal MongoDB use.
class Timestamp {
public:
    /// @brief Creates an empty timestamp
    /// @note MongoDB only replaces empty timestamps in top-level fields.
    Timestamp();
 
    /// Creates a timestamp with specified values
    Timestamp(uint32_t timestamp, uint32_t increment);
 
    /// Returns stored unix timestamp
    time_t GetTimestamp() const;
 
    /// Returns stored increment
    uint32_t GetIncrement() const;
 
    /// Returns packed 64-bit timestamp value
    uint64_t Pack() const;
 
    /// Restores a timestamp from the packed form
    static Timestamp Unpack(uint64_t);
 
    bool operator==(const Timestamp&) const;
    bool operator!=(const Timestamp&) const;
    bool operator<(const Timestamp&) const;
    bool operator>(const Timestamp&) const;
    bool operator<=(const Timestamp&) const;
    bool operator>=(const Timestamp&) const;
 
private:
    uint32_t timestamp_{0};
    uint32_t increment_{0};
};
 
}  // namespace formats::bson
 
USERVER_NAMESPACE_END
 
namespace std {
 
template <>
struct hash<USERVER_NAMESPACE::formats::bson::Oid> {
    size_t operator()(const USERVER_NAMESPACE::formats::bson::Oid&) const;
};
 
template <>
struct hash<USERVER_NAMESPACE::formats::bson::Binary> {
    size_t operator()(const USERVER_NAMESPACE::formats::bson::Binary& binary) const {
        return hash<string>()(binary.data_);
    }
};
 
template <>
struct hash<USERVER_NAMESPACE::formats::bson::Timestamp> {
    size_t operator()(const USERVER_NAMESPACE::formats::bson::Timestamp& timestamp) const;
};
 
}  // namespace std
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::formats::bson::Oid> {
    constexpr static auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template <typename FormatContext>
    auto format(USERVER_NAMESPACE::formats::bson::Oid oid, FormatContext& ctx) USERVER_FMT_CONST {
        return fmt::format_to(ctx.out(), "{}", oid.ToString());
    }
};