bson.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef REALMCXX_BSON_HPP
REALMXX_BSON_HPP を定義する
 
#include <cpprealm/types.hpp>
#include <cpprealm/ internal/bridge/uts.hpp>
#include <any>
 
名前空間邦土 {
    名前空間BSON {
        クラスBSON 、
        クラスBsonDocument
        struct RegularExpression。
 }
 
 
    構造体 bsoncxx {
 
        配列 = 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
 };
 
        構造体 ドキュメント{
            CoreDocument = Realm::bson::BsonDocumentを使用）
 
            構造体 値{
                値& 演算子=( const bsoncx & v):
                演算子 bsoncxx() const;
                convert std::string キー
            private :
                友人 構造体 bsoncxx;
                explicit 値（CoreDocument* d、 const std::string+k）
 : key(k), m_document(d) {}
 CoreDocument* m_document
 };
 
            構造体 イテレータ{
 ）
                イテレータ& 演算子 ++()。
                イテレータと演算子-()。
                イテレータ& 演算子 ++( int )。
                イテレータと演算子-( int )。
                ブール演算子!=( const イテレータとrhs ）は 以外と一致しません 。
                ブール演算子== (コンリスト:
            private :
                友人 構造体 document;
                イテレータ（std::any & & i） : m_literal(i) { }
 std::任意の m_item
 };
            イテレータstart()。
            イテレータend()
 
            ドキュメント（）は例外を除き、
            ドキュメント（const std::initializer_list=std::pear=std:: string , bsoncx >=================================================================
            document(const document&);
            document(document&&);
 ～ドキュメント（）
            ドキュメント& 演算子=(constドキュメントと):
            ドキュメント& 演算子=(ドキュメントと ):
            無効挿入(const std:: string & キー、const bsoncx &値)。
            ブール値空 ()。
            size_t size() 変換
            値演算子[](const std:: string &)
演算子 CoreDocument() 規則
            ドキュメント（CoreDocument &) は例外を除き、
 private:
 MongoDB_ENUS_JAJP
#ifdef CPREALM_HAV_GENERTED_BRIDGE_TypeS
 internal::bridge::storage::BsonIndexedMap m_document[ 1 ]
#else
std::shared_ptr[CoreDocument]m_document<CoreDocument>
#endif
 };
 
        構造体 min_key {}
        構造体 max_key {}
 
        構造体 正規表現{
            列挙クラスオプション : uint 8 _t {
なし、
 ignore_case = 1,
複数行 = 2 、
ドット = 4 、
拡張 = 8
 };
            正規表現（ const std::string+ パターン、 const std::string+ オプション）。
            正規表現（ const std::string+ パターン、オプション オプション）
            正規表現()
オプション get_options() がconst 、
 std::string get_pattern() const
            演算子realm::bson::regularExpression() const 。
        private :
            友人 構造体 bsoncxx;
            正規表現（ constrealm ::bson:: regularExpression ())。
 option m_options;
 std::string m_pattern
 };
 
        構造体 タイムスタンプ{
            explicit タイムスタンプ（uint 32 _t 秒、uint 32 _t 増分） : m_seconds( 秒)、m_increment(増分) {}
uint32 _t get_seconds() は、{ return m_seconds を返す を除く例外として、 const ではありません。 }
uint32 _t get_increment () は { return m_increment () を返す場合を除きます。 }
        private :
            友人 構造体 bsoncxx;
            const uint 32 _t m_seconds
            const uint32_t m_increment;
 };
 
        構造体 日付{
            explicit 日付 <std::chrono::system_clock>（ const std::chrono::time_point未満:
std::chrono::time_point<std::chronno: system_lock<std::chrono::system_clock> > get_date() connect_date () は、n_date を 返し ます}
        private :
            友人 構造体 bsoncxx;
            const std::chrono::time_point=std::Error:system_lock><std::chrono::system_clock> m_date
 };
 
        bsoncx () は例外を除き、
 ～ bsoncx () は例外を除きます。
        bsoncx (const bsoncx &) optime は例外をスローします。
        bsoncxx(bsoncxx&&) noexcept;
        bsoncx & 演算子=(const bsoncx &) no例外:
        bsonc機能
 
        bsoncx (int 32 _t) は例外を除きます。
        bsoncx (int 64 _t) は例外を除きます。
        bsoncx ( bool ) no例外:
        bsoncx （ double ）ではない場合
        bsoncx ( min_key ) no例外:
        bsoncx ( max_key ) no例外:
        bsoncx (constタイムスタンプと) no例外:
        bsoncx (const date &) no例外:
        bsoncx （const 10進数128 &）
        bsoncx (const object_id &) no例外:
        bsoncxx(const uuid&) noexcept;
        bsoncx (const Regular_ Expression &) noException
        bsonc 8
        bsonc機能（const std:: string &）
        bsoncx (const char *) no例外:
        bsoncx (const document &) no例外:
        bsonc機能
 type get_type()const
演算子 Realm::bson::Bson()const
 
演算子 std::nullopt_t() 条件
演算子 int 32 _t() Const
演算子 int 64 _t() Const
演算子ブール値（）const。
演算子double （）制約
演算子min_key （）const
演算子max_key （）const
演算子タイムスタンプ（）const
演算子date （）const
演算子10 進数128 （）const
演算子object_id （）const
演算子uuid （）const
演算子regular_ Expression （）const
演算子 std::vector<uint 8 _t>()const
演算子 std:: string （）const
演算子ドキュメント（）const
演算子 array()const
 
 std:: string to_string()const
 std:: string to_json()const
        bsoncx （realm::bson::Bson=
 private:
#ifdef CPREALM_HAV_GENERTED_BRIDGE_TypeS
 internal::bridge::storage::Bson m_bson[ 1 ],
#else
std::shared_ptr[realm::bson::Bson><realm::bson::Bson> m_bson]
#endif
 };
 
    ブール演算子==( const bsoncx & Lhs、 const bsonc機能、rhs)。
    ブール演算子!=( const bsonc 機能
    ブール演算子==( const bsoncx::document & Lhs、 const bsoncx::document &rhs):
    ブール演算子!=( const bsoncx::document & Lhs、 const bsoncx::document &rhs）。
    ブール演算子==( const bsoncx::regular_ Expression & Lhs、 const bsoncx::regular_ Expression &rhs)は 以外となります。
    ブール演算子!=( const bsoncx::regular_ Expression & Lhs、 const bsoncx::regular_ Expression &rhs）は 以外となります。
 bsonc機能
                                                  const bsoncx ::regular_ Expression::option+rhs） は 以外となります 。
 bsoncx::regular_ Expression::option 演算子=( const bsoncx::regular_ Expression::option===========================================================
                                                  const bsoncx ::regular_ Expression::option+rhs） は 以外となります 。
} // namespace realm
 
#endif//REALMCXX_BSON_HPP