obj.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 CPPREALM_BRIDGE_OBJ_HPP
#define CPPREALM_BRIDGE_OBJ_HPP
 
#include <any>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
#include <cprealm/types.hpp>
#include <cpprealm/internal/bridge/binary.hpp>
#include <cpprealm/internal/bridge/col_key.hpp>
#include <cpprealm/internal/bridge/decimal128.hpp>
#include <cprealm/internal/bridge/Dictionary.hpp>
#include <cpprealm/internal/bridge/ objeto.hpp>
#include <cpprealm/internal/bridge/object_id.hpp>
#include <cprealm/internal/bridge/table.hpp>
#include <cprealm/internal/bridge/utils.hpp>
 
namespace Realm {
    grupo de classe  ;
    classe Realm;
    classe Timestamp;
    classe Objeto;
    classe ObjectSchema;
    classe Obj;
    class TableRef;
    query de classe  ;
    struct ColKey;
    classe LnkLst;
    struct NotificationToken;
 
    namespace interno::bridge {
        estruturado obj_key;
        estruturado obj_link;
 }
    namespace internal::type_info {
        modelo <typename, typename>
        estrutura, estrutura type_info;
 }
 
    modelo <typename, typename>
    estrutura, estrutura managed;
    modelo <typename, typename>
    estrutura, estrutura acessador;
}
 
namespace realm::internal::bridge {
    estrutura obj;
    estrutura mista;
    domínio estruturado  ;
    struct lnklst;
    query de estrutura  ;
    estrutura object_schema;
    carimbo de data/hora da estrutura  ;
    estruturado obj_key;
    estruturado obj_link;
    tabela estrutura  ;
    dicionário estruturado  ;
    estrutura, estrutura uuid;
    estrutura, estrutura object_id;
    estrutura, estrutura decimal128;
    lista de estruturas  ;
    linha estrutura  ;
    estrutura table_view;
 
    namespace {
        modelo <typename T>
        estrutura is_optional : std::false_type {
            utilizando subjacente = T;
 };
 
        modelo <typename T>
        estrutura is_optional<std::opcional<T>> : std::true_type {
            utilizando subjacente = T;
 };
 }
 
    modelo <typename T>
 [[nodiscard]] T get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] std::string get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] uuid get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] object_id get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] decimal128 get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] binary get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] timestamp get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] int64_t get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] double get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] bool get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] mixed get(const obj&, const col_key& col_key);
    modelo <>
 [[nodiscard]] core_Dictionary get(const obj&, const col_key& col_key);
 
    estrutura, estrutura obj {
        obj();
        obj(const obje outros);
        obj& operator=(const obj& other) ;
        obj(obj&& outro);
        obj& operator=(obj&& other);
        ~obj();
        obj(const Obj&); //NOLINT google-explicit-constructor
        operador Obj() const; //NOLINT google-explicit-constructor
 [[nodiscard]] table get_table() const noexceto;
 [[nodiscard]] table get_target_table(col_key) const noexceto;
 [[nodiscard]] bool is_null(const col_key& col_key) const;
 [[nodiscard]] bool is_valid() const;
 [[nodiscard]] obj get_linked_object(const col_key& col_key);
        modelo <typename T>
 T get(const col_key& col_key) const {
            return internal::bridge::get<T>(*this, col_key);
 }
 
        modelo <typename T>
 std::optional<T> get_optional(const col_key& col_key) const {
            se (is_null(col_key)) {
                return std::nullopt;
 }
            return internal::bridge::get<T>(*this, col_key);
 }
 
        vazio set(const col_key& col_key, const int64_t& valor);
        vazio set(const col_key& col_key, const double& value);
        vazio set(const col_key& col_key, const std::string& valor);
        vazio set(const col_key& col_key, const misto& valor);
        vazio set(const col_key& col_key, const bool& value);
        vazio set(const col_key& col_key, const timestamp& value);
        vazio set(const col_key& col_key, const binary& value);
        vazio set(const col_key& col_key, const uuid& value);
        vazio set(const col_key& col_key, const object_id& value);
        vazio set(const col_key& col_key, const decimal128& value);
        vazio set(const col_key& col_key, const obj_key& value);
        vazio set(const col_key& col_key, const std::chrono::time_point<std::chrono::system_clock>& value);
        modelo<typename T>
 std::enable_if_t<std::is_enum_v<T>> set(const col_key& col_key, const T& valor) {
            set <int64_t>(col_key, static_cast <int64_t>(valor));
 }
        modelo<typename T>
        vazio set(const col_key& col_key, const std::optional<T>& valor) {
            se (valor) {
                set(col_key, *value);
 } mais {
 set_null(col_key);
 }
 }
 
        set_list_values (const col_key& col_key, const std::vector<obj_key>& valores);
        set_list_values (const col_key& col_key, const std::vector<std::string>valores);
        set_list_values (const col_key& col_key, const std::vector<bool>& valores);
        set_list_values (const col_key& col_key, const std::vector<int64_t>& valores);
        set_list_values (const col_key& col_key, const std::vector<double>& valores);
        set_list_values (const col_key& col_key, const std::vector<internal::bridge::uuid>& valores);
        set_list_values (const col_key& col_key, const std::vector<internal::bridge::object_id>& valores);
        set_list_values nulos (const col_key& col_key, const std::vector<internal::bridge::decimal128>& valores);
        set_list_values vazios ( valores const col_key& col_key, const std::vector<binary>&);
        set_list_values vazios ( valores const col_key& col_key, const std::vector<mixed>&);
        set_list_values (const col_key& col_key, const std::vector<timestamp>& valores);
 
        void set_list_values(const col_key& col_key, const std::vector<std::optional<int64_t>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<bool>>& values);
        set_list_values vazias (const col_key& col_key, const std::vector <std::optional<double>> valores);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<std::string>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<obj_key>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<internal::bridge::uuid>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<internal::bridge::object_id>>& values);
        set_list_values vazias (const col_key& col_key, const std::vector<std::optional<binary>>& valores);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<timestamp>>& values);
 
        modelo <typename ValueType>
        set_list_values nulos (const col_key& col_key, const std::vector<ValueType>& valores) {
 std::vector<typename internal::type_info::type_info<ValueType, null>::internal_type> v2;
            para ( valores v :automático ) {
                se constexpr (std::is_pointer_v<ValueType>) {
                    interno::ponte::obj m_obj;
                    se constexpr (managed <std::remove_pointer_t<ValueType>, null >:: schema.HasPrimaryKeyProperty ) {
                        auto pk = (*v).*(managed <std::remove_pointer_t<ValueType>, null >:: schema.primary_key ().ptr);
 m_obj = esta->get_table().create_object_with_primary_key(internal::bridge::mixed(serialize(pk.value)));
 } mais {
 m_obj = m_obj = esta->get_table().create_object();
 }
 std::apply([&m_obj, &v](auto && ...p) {
 (acessador<typename std::decay_t<decltype(p)>::Result, null>::set(
 m_obj, m_obj.get_table().get_column_key(p.name),
 (*v).*(std::decay_t<decltype(p)>::ptr)), ...);
 }, managed<std::remove_pointer_t<ValueType>, null >:: schema.ps );
 v2.push_back(m_obj.get_key());
 } mais {
 v2.push_back(:: Realm::serialize(v));
 }
 }
 set_list_values(col_key, v2);
 }
 
 [[nodiscard]] obj_key get_key() const;
 [[nodiscard]] obj_link get_link() const;
        lnklst get_linklist(const col_key& col_key);
        core_Dictionary get_Dictionary(const col_key& col_key);
        set_null (const col_key&);
        obj create_and_set_linked_object(const col_key&);
        table_view get_backlink_view(table, col_key);
        to_json (std::ostream& out) const noexceto;
    privado:
        in-line const Obj* get_obj() const;
        inline Obj* get_obj();
        amigo in-line const Obj* get_obj(const obj&);
        amigo inline Obj* get_obj(obj&);
        modelo <typename T>
        amigo T get(const obj&, const col_key& col_key);
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::Obj m_obj[1];
#else
 std::shared_ptr<Obj> m_obj;
#endif
 };
 
    estrutura, estrutura grupo {
        grupo(Realm&);
        tabela get_table(uint32_t table_key);
        tabela get_table(const std::string& table_key);
    privado:
 std::reference_wrapper<realm> m_realm;
 };
 
 std::string table_name_for_object_type(const std::string&);
}
 
 
#endif //CPPrealm_BRIDGE_OBJ_HPP