bson.hpp

 
//
// Autores 2024 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef REALMCXX_BSON_HPP
#define RealMCXX_BSON_HPP
 
#include <cprealm/types.hpp>
#include <cprealm/internal/bridge/utils.hpp>
#include <any>
 
namespace Realm {
    namespace BSON {
        classe BSON;
        classe Documento BSON;
        estrutura RegularExpression;
 }
 
 
    estrutura, estrutura bsoncxx {
 
        usando array = std::vector<bsoncxx>;
 
        tipo de classe enumeração {
 b_null,
 b_int32,
 b_int64,
 b_bool,
 b_double,
 b_string,
 b_binary,
 b_timestamp,
 b_datetime,
 b_objectId,
 b_decimal128,
 b_regular_expression,
 b_max_key,
 b_min_key,
 b_document,
 b_array,
 b_uuid
 };
 
        estrutura, estrutura documento {
            usando CoreDocument = realm::bson::BsonDocument;
 
            estrutura, estrutura valor {
                valor& operador=(const bsoncxx& v);
                operador, operador bsoncxx() const;
                const std::string key;
            privado:
                amigo estrutura, estrutura bsoncxx;
                explícito valor(CoreDocument* d, const std::string& k)
 : key(k), m_document(d) {}
 CoreDocument* m_document;
 };
 
            estrutura, estrutura iterador {
 std::pair<std::string, bsoncxx> operador*();
                iteradore operador++();
                iteradore operador--();
                iteradore operador++(int);
                iteradore operador--(int);
                operador de bool !=(const iteradore rhs) const noexceto;
                bool operator==(const iteradore rhs) const noexceto;
            privado:
                amigo estrutura, estrutura document;
                iterator(std::any&& i) : m_iterator(i) { }
 std::any m_iterator;
 };
            iterador begin();
            iterador end();
 
            documento() noexceto;
            documento(const std::initializer_list<std::pair<std::string, bsoncxx>>&) noexceto;
            document(const document&);
            document(document&&);
 ~documento();
            documento& operator=( documentoconst &);
            documento& operator=(documento&&);
            inserção vazia (const std::string& chave, const bsoncxx& valor);
            bool empty();
            size_t size() const;
            operador de valor [](const std::string&);
 operador CoreDocument() const;
            documento(CoreDocument&) noexceto;
 privado:
 estrutura de amigo bsoncxx;
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::BsonIndexedMap m_document[1];
#else
 std::shared_ptr<CoreDocument> m_document;
#endif
 };
 
        estrutura, estrutura min_key {};
        estrutura, estrutura max_key {};
 
        estrutura, estrutura regular_expression {
            opção de classe enumeração : uint8_t {
 nenhum,
 ignore_case = 1,
 multilinha = 2,
 dotall = 4,
 estendido = 8
 };
            expressão regular(const std::string& padrão, const std::string& opções);
            expressão regular(const std::string& padrão, opções de opção);
            regular_expression();
 opção get_options() const;
 std::string get_pattern() const;
            operador realm::bson::RegularExpression() const;
        privado:
            amigo estrutura, estrutura bsoncxx;
            regular_expression(const Realm::bson::RegularExpression&);
 option m_options;
 std::string m_pattern;
 };
 
        estrutura, estrutura timestamp {
            explícito carimbo de data/hora (uint32_t segundos, uint32_t incremento) : m_seconds(segundos), m_increment(increment)
 uint32_t get_seconds() const noexceto { return m_seconds; }
 uint32_t get_increment() const noexceto { return m_increment; }
        privado:
            amigo estrutura, estrutura bsoncxx;
            const uint32_t m_seconds;
            const uint32_t m_increment;
 };
 
        estrutura, estrutura data {
            explícito data (const std::chrono::time_pointcada<std::chrono::system_clock>vez mais
 std::chrono::time_point<std::chrono::system_clock> get_date() const noexceto { return m_date; }
        privado:
            amigo estrutura, estrutura bsoncxx;
            const std::chrono::time_point<std::chrono::system_clock> m_date;
 };
 
        bsoncxx() noexceto;
 ~bsoncxx() noexceto;
        bsoncxx(const bsoncxx&) noexceto;
        bsoncxx(bsoncxx&&) noexcept;
        bsoncxx& operator=(const bsoncxx&) noexceto;
        bsoncxx& operator=(bsoncxx&&) noexceto;
 
        bsoncxx(int32_t) noexceto;
        bsoncxx(int64_t) noexceto;
        bsoncxx(bool) noexceto;
        bsoncxx(double) noexceto;
        bsoncxx(min_key) noexceto;
        bsoncxx(max_key) noexceto;
        bsoncxx( carimbode data/hora constante &) noexceto;
        bsoncxx( dataconst &) noexceto;
        bsoncxx(const decimal128&) noexceto;
        bsoncxx(const object_id&) noexceto;
        bsoncxx(const uuid&) noexcept;
        bsoncxx(const regular_expression&) noexceto;
        bsoncxx(const std::vector<uint8_t>&) noexceto;
        bsoncxx(const std::string&) noexceto;
        bsoncxx(const chart *) noexceto ;
        bsoncxx( documentoconst &) noexceto;
        bsoncxx(const array&) noexceto;
 digite get_type() const;
 operador Realm::bson::Bson() const;
 
 operador std::nullopt_t() const;
 operador int32_t() const;
 operador int64_t() const;
 operador bool() const;
 operador double() const;
 operador min_key() const;
 operador max_key() const;
 carimbo de data/ hora do operador () const;
 data do operador () const;
 operador decimal128() const;
 operador object_id() const;
 operador uuid() const;
 operador regular_expression() const;
 operador std::vector<uint8_t>() const;
 operador std::string() const;
 documento do operador () const;
 operador array() const;
 
 std::string to_string() const;
 std::string to_json() const;
        bsoncxx(Realm::bson::Bson&) noexceto;
 privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::Bson m_bson[1];
#else
 std::shared_ptr<realm::bson::Bson> m_bson;
#endif
 };
 
    bool operator==(const bsoncxx& lhs, const bsoncxx& rhs);
    operador de bool !=(const bsoncxx& lhs, const bsoncxx& rhs);
    bool operator==(const bsoncxx:: documento& lhs, const bsoncxx:: documento& rhs);
    operador de bool !=(const bsoncxx:: documento& lhs, const bsoncxx:: documento& rhs);
    bool operator==(const bsoncxx::regular_expression& lhs, const bsoncxx::regular_expression& rhs) noexceto;
    operador de bool !=(const bsoncxx::regular_expression& lhs, const bsoncxx::regular_expression& rhs) noexceto;
 bsoncxx::regular_expression::operador de opção|(const bsoncxx::regular_expression::opção& lhs,
                                                  const bsoncxx::regular_expression::option& rhs) noexceto;
 bsoncxx::regular_expression::option operator&(const bsoncxx::regular_expression::option& lhs,
                                                  const bsoncxx::regular_expression::option& rhs) noexceto;
} // namespace realm
 
#endif//REALMCXX_BSON_HPP