serialize.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/bson/serialize.hpp
/// @brief Textual serialization helpers
 
#include <iosfwd>
#include <string>
#include <string_view>
 
#include <fmt/core.h>
 
#include <userver/compiler/select.hpp>
#include <userver/formats/bson/document.hpp>
#include <userver/formats/bson/value.hpp>
#include <userver/formats/json_fwd.hpp>
#include <userver/logging/log_helper_fwd.hpp>
#include <userver/utils/fast_pimpl.hpp>
#include <userver/utils/fmt_compat.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::parse {
 
formats::json::Value Convert(const formats::bson::Value& bson, formats::parse::To<formats::json::Value>);
formats::bson::Value Convert(const formats::json::Value& json, formats::parse::To<formats::bson::Value>);
 
}  // namespace formats::parse
 
namespace formats::bson {
 
/// Wraps To*JsonString results to avoid unneeded copying
class JsonString;
 
/// Applies heuristics to convert JSON string to BSON document.
/// As JSON have rather lax typing, some heuristics are applied to guess correct
/// BSON types for values. It is strongly recommended to write your own
/// conversion routines matching your schemas.
/// @warning Stability of heuristics is not guaranteed, this is provided as-is.
Document FromJsonString(std::string_view json);
 
/// Applies heuristics to convert JSON string to BSON array.
/// As JSON have rather lax typing, some heuristics are applied to guess correct
/// BSON types for values. It is strongly recommended to write your own
/// conversion routines matching your schemas.
/// @warning Stability of heuristics is not guaranteed, this is provided as-is.
Value ArrayFromJsonString(std::string_view json);
 
/// Converts BSON to a canonical MongoDB Extended JSON format.
/// @see
/// https://github.com/mongodb/specifications/blob/master/source/extended-json.rst
JsonString ToCanonicalJsonString(const formats::bson::Document&);
 
/// Converts BSON to a relaxed MongoDB Extended JSON format.
/// Notable differences from canonical format are:
///  * numbers are not being wrapped in `$number*` objects;
///  * dates have string representation.
/// @see
/// https://github.com/mongodb/specifications/blob/master/source/extended-json.rst
JsonString ToRelaxedJsonString(const formats::bson::Document&);
 
/// Converts BSON to a legacy libbson's JSON format.
/// Notable differences from other formats:
///  * all numbers are not wrapped;
///  * non-standard tokens for special floating point values;
///  * dates are milliseconds since epoch;
///  * different format for binaries.
JsonString ToLegacyJsonString(const formats::bson::Document&);
 
/// Converts BSON array to a legacy libbson's JSON format, except the outermost
/// element is encoded as a JSON array, rather than a JSON document.
JsonString ToArrayJsonString(const formats::bson::Value&);
 
namespace impl {
class JsonStringImpl;
}  // namespace impl
 
class JsonString {
public:
    /// @cond
    explicit JsonString(impl::JsonStringImpl&&);
    /// @endcond
    ~JsonString();
 
    /// Implicitly convertible to string
    /*implicit*/ operator std::string() const { return ToString(); }
 
    /// Returns a copy of the string
    std::string ToString() const;
 
    /// Returns a view of the string
    std::string_view GetView() const;
 
    const char* Data() const;
    size_t Size() const;
 
private:
    static constexpr std::size_t kSize = compiler::SelectSize()  //
                                             .For64Bit(16)
                                             .For32Bit(8);
    static constexpr std::size_t kAlignment = alignof(void*);
    utils::FastPimpl<impl::JsonStringImpl, kSize, kAlignment, utils::kStrictMatch> impl_;
};
 
std::ostream& operator<<(std::ostream&, const JsonString&);
 
logging::LogHelper& operator<<(logging::LogHelper&, const JsonString&);
 
/// Uses formats::bson::ToRelaxedJsonString representation by default.
logging::LogHelper& operator<<(logging::LogHelper&, const Document&);
 
}  // namespace formats::bson
 
USERVER_NAMESPACE_END
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::formats::bson::JsonString> : public fmt::formatter<std::string_view> {
    template <typename FormatContext>
    auto format(const USERVER_NAMESPACE::formats::bson::JsonString& json, FormatContext& ctx) USERVER_FMT_CONST {
        return fmt::formatter<std::string_view>::format(json.GetView(), ctx);
    }
};
 
/// Uses formats::bson::ToRelaxedJsonString representation by default.
template <>
struct fmt::formatter<USERVER_NAMESPACE::formats::bson::Document> : public fmt::formatter<std::string_view> {
    template <typename FormatContext>
    auto format(const USERVER_NAMESPACE::formats::bson::Document& bson, FormatContext& ctx) USERVER_FMT_CONST {
        return fmt::formatter<std::string_view>::format(
            USERVER_NAMESPACE::formats::bson::ToRelaxedJsonString(bson).GetView(), ctx
        );
    }
};