bson.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef REALMCXX_BSON_HPP
#define REALMCXX_BSON_HPP
 
#include <cpprealm/types.hpp>
#include <cpprealm/internal/bridge/utils.hpp>
#include <any>
 
命名空间域 {
    命名空间BSON {
        class BSON ；
        class BsonDocument;
        struct正则表达式；
 }
 
 
    struct bsoncxx {
 
        using 大量 = std::vector<bsoncxx>;
 
        枚举类类型{
 b_null,
 b_int32,
 b_int64,
 b_bool,
 b_double,
 b_string,
 b_binary,
 b_timestamp,
 b_datetime,
 b_objectId,
 b_decimal 128 ，
 b_regular_expression,
 b_max_key,
 b_min_key,
 b_document,
 b_array,
 b_uuid
 }；
 
        struct 文档{
            using CoreDocument = realm::bson::BsonDocument;
 
            struct 值{
                value & Operator=( const bsoncxx & v);
                运算符 bsoncxx() const;
                const std::string key;
            private :
                朋友 struct bsoncxx ；
                显式 value (CoreDocument* d, const std::string& k)
 : key(k), m_document(d) {}
 CoreDocument* m_document;
 }；
 
            struct 迭代器{
 std::pair<std::string, bsoncxx> 操作符*();
                迭代器和操作符++（）；
                迭代器和操作符--();
                iterator & Operator++( int );
                迭代器和操作符--( int );
                bool操作符!=( const iterator & rhs) const noException ;
                bool 操作符==( const iterator & rhs) const noException ;
            private :
                朋友 struct document;
                iterator (std::any&& i) : m_iterator(i) { }
 std::any m_iterator;
 }；
            迭代器begin();
            iterator end();
 
            文档 () noException;
            文档 (const std::initializer_list<std::pair<std:: string , bsoncxx >>&) noException;
            document(const document&);
            document(document&&);
 ~ 文档 ();
            文档 & 操作符=(const 文档 &);
            文档 & 操作符=( 文档 &&);
            void insert(const std:: string & key, const bsoncxx & value );
            bool empty();
            size_t size() const;
            value 操作符[](const std:: string &);
 Operator CoreDocument() const;
            文档 (CoreDocument&) noException;
私有：
友元 struct bsoncxx ；
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 存储::BsonIndexedMap m_document[ 1 ];
#else
 std::shared_ptr<CoreDocument> m_document;
#endif
 }；
 
        struct min_key {};
        struct max_key {};
 
        struct 正则表达式{
            枚举类选项：uint 8 _t {
无，
 ignore_case = 1 ，
 multiline = 2 ，
 dotall = 4 ，
扩展 = 8
 }；
            regular_expression ( const std::string& 模式, const std::string& options);
            regular_expression ( const std::string& 模式, option options);
            regular_expression ();
 option get_options() const ;
 std::string get_pattern() const ；
            运算符Realm::bson::RegularExpression() const ;
        private :
            朋友 struct bsoncxx ；
            regular_expression ( const 域::bson::RegularExpression&);
 option m_options;
 std::string m_pattern;
 }；
 
        struct 时间戳{
            显式 timestamp (uint 32 _tseconds, uint 32 _tincrement) : m_seconds(seconds), m_increment(increment) {}
 uint 32 _t get_seconds() const noException { return m_seconds; }
 uint 32 _t get_increment() const noException { return m_increment; }
        private :
            朋友 struct bsoncxx ；
            const uint 32 _t m_seconds;
            const uint32_t m_increment;
 }；
 
        struct 日期{
            显式 date ( const std::chrono::time_point<std::chrono::system_clock>& d) : m_date(d) {}
 std::chrono::time_point<std::chrono::system_clock> get_date() const noException { return m_date; }
        private :
            朋友 struct bsoncxx ；
            const std::chrono::time_point<std::chrono::system_clock> m_date;
 }；
 
        bsoncxx () noException;
 ~ bsoncxx () noException;
        bsoncxx (const bsoncxx &) noException;
        bsoncxx(bsoncxx&&) noexcept;
        bsoncxx & 操作符=(const bsoncxx &) noException;
        bsoncxx & 操作符=( bsoncxx &&) noException;
 
        bsoncxx (int 32 _t) noException;
        bsoncxx (int 64 _t) noException;
        bsoncxx ( bool ) noException；
        bsoncxx ( double ) noException;
        bsoncxx ( min_key ) noException;
        bsoncxx ( max_key ) noException;
        bsoncxx (const timestamp &) noException;
        bsoncxx (const date &) noException;
        bsoncxx (const Decimal 128 &) noException;
        bsoncxx (const object_id &) noException;
        bsoncxx(const uuid&) noexcept;
        bsoncxx (const Regular_expression &) noException;
        bsoncxx (const std::vector<uint 8 _t>&) noException;
        bsoncxx (const std:: string &) noException;
        bsoncxx (const char *) noException;
        bsoncxx (const 文档 &) noException;
        bsoncxx (const array&) noException;
 type get_type() const;
 操作符 域::bson::Bson() const;
 
 操作符 std::nullopt_t() const;
 操作符 int 32 _t() const;
 操作符 int 64 _t() const;
 操作符 bool () const;
 Operator double () const;
 操作符 min_key () const;
 操作符 max_key () const;
 Operator timestamp () const;
 操作符 date () const;
操作符十进制128 () const;
 操作符 object_id () const;
 操作符 uuid () const;
操作符正则表达式() const;
 操作符 std::vector<uint 8 _t>() const;
 操作符 std:: string () const;
 Operator document () const;
 操作符 大量() const;
 
 std:: string to_string() const;
 std:: string to_json() const;
        bsoncxx (域::bson::Bson&) noException;
私有：
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 存储::Bson m_bson[ 1 ];
#else
std::shared_ptr<realm::bson::Bson> m_bson;
#endif
 };
 
    bool Operator==( const bsoncxx & lhs, const bsoncxx & rhs);
    bool操作符!=( const bsoncxx & lhs, const bsoncxx & rhs);
    bool 操作符==( const bsoncxx:: 文档 & lhs, const bsoncxx:: 文档 & rhs);
    bool操作符!=( const bsoncxx:: 文档 & lhs, const bsoncxx:: 文档 & rhs);
    bool Operator==( const bsoncxx::regular_expression & lhs, const bsoncxx::regular_expression & rhs) noException ;
    bool操作符!=( const bsoncxx::regular_expression & lhs, const bsoncxx::regular_expression & rhs) noException ;
 bsoncxx::regular_expression::option 操作符|( const bsoncxx::regular_expression::option& lhs,
                                                  const bsoncxx::regular_expression::option& rhs) noException ;
 bsoncxx::regular_expression::option Operator&( const bsoncxx::regular_expression::option& lhs,
                                                  const bsoncxx::regular_expression::option& rhs) noException ;
 } // 命名空间 Realm
 
#endif//REALMCXX_BSON_HPP