schema.hpp

 
//
// Autores 2022 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_SCHEMA_HPP
#define CPPREALM_SCHEMA_HPP
 
#include <cpprealm/link.hpp>
#include <cpprealm/internal/bridge/lnklst.hpp>
#include <cpprealm/internal/bridge/object_schema.hpp>
#include <cprealm/internal/bridge/realm.hpp>
#include <cprealm/internal/bridge/table.hpp>
#include <cpprealm/internal/type_info.hpp>
#include <variant>
 
#include <type_traits>
#include <iostream>
 
namespace Realm {
    enum class ObjectType {
 Nenhum,
 TopLevel,
 incorporado,
 assimétrico
 };
    namespace interno {
        modelo <typename T>
        estrutura, estrutura ptr_type_extractor_base;
        template <typename Resultado, typename Class>
        estrutura, estrutura ptr_type_extractor_base<Classe de resultados::*>
 {
            usando class_type = Classe;
            usando member_type = Resultado;
 };
 
        template <auto T>
        estrutura, estrutura ptr_type_extractor : ptr_type_extractor_base<decltype(T)> {
 };
 
        template<typename... Typescript>
        constexpr auto get_subpack_tuple(Ts&&... xs)
 {
            return std::tuple<Ts...>(std::forward<Ts>(xs)...);
 }
 
        modelo <typename T>
        estrutura, estrutura persisted_type_extractor {
            usando Resultado = T;
 };
 }
 
 
    //MARK: esquema
    esquema de namespace  {
        template <auto Ptr, bool IsPrimaryKey = false>
        estrutura, estrutura propriedade {
            usando Result = typename internal::persisted_type_extractor<typename internal::ptr_type_extractor<Ptr>::member_type>::Result;
            usando VariantResult =
 std::optional_t<std::is_pointer_v<Result>, managed<Result>, Result>;
 
            usando Class = typename internal::ptr_type_extractor<Ptr>::class_type;
            estático constexpr auto ptr = Ptr;
            estático constexpr bool is_primary_key = IsPrimaryKey || internal::type_info::is_primary_key<Result>::value;
 internal::bridge::property::type type;
            const chart* nome = "";
 
            constexpr propriedade() : type(internal::type_info::type_info<Result>::type())
 {
 }
            explícito constexpr propriedade(const caracteres* real_name)
 : type(internal::type_info::type_info<Result>::type())
 {
 nome = real_name;
 }
 
            operador, operador internal::bridge:: propriedade() const {
                internal::bridge::property propriedade(nome, tipo, is_primary_key);
                se constexpr (realm::internal::type_info::is_vector<Result>::value) {
                    se constexpr (std::is_pointer_v<typename Result::value_type>) {
                        propriedade.set_object_link(gerenciado<std::remove_pointer_t<typename Resultado::value_type>, void>::schema.name);
 }
 } mais se constexpr (realm::internal::type_info::is_set<Result>::value) {
                    se constexpr (std::is_pointer_v<typename Result::value_type>) {
                        propriedade.set_object_link(gerenciado<std::remove_pointer_t<typename Resultado::value_type>, void>::schema.name);
 }
 } mais se constexpr (Realm::internal::type_info::is_map<Result>::value) {
                    se constexpr (internal::type_info::is_optional<typename Result::mapped_type>::value) {
                        se constexpr (internal::type_info::is_link<typename Result::mapped_type::value_type>::value) {
                            propriedade.set_object_link(gerenciado<std::remove_pointer_t<typename Resultado::mapped_type::value_type>, null >:: schema.name );
                            propriedade.set_type(type | internal::bridge::property::type::Nullable);
 }
 } mais se constexpr (std::is_pointer_v<typename Result::mapped_type>) {
                        propriedade.set_object_link(gerenciado<std::remove_pointer_t<typename Resultado:: mapped_type>, null >::schema.name);
                        propriedade.set_type(type | internal::bridge::property::type::Nullable);
 }
 } mais se constexpr (std::is_pointer_v<Result>) {
                    propriedade.set_object_link(managed<typename std::remove_pointer_t<Result>, void>::schema.name);
                    propriedade.set_type(type | internal::bridge::property::type::Nullable);
 } mais se constexpr (internal::type_info::is_backlink<Result>::value) {
                    Método internal::bridge:: propriedade{};
 }
 
                Método propriedade;
 }
 };
 
        template <typename T, typename ... Types>
        estrutura, estrutura unique_variant {
            usando tipo = T;
 };
 
        modelo < modelo nome do tipoVariant, nomedo tipo... VariantTypes , nomedo tipo NextType , nome do tipo ... RemainingTypes>
        estrutura, estrutura unique_variant<Variant<VariantTypes...> , NextType, RemainingTypes...>
 : std:: requires
 std::disjunction< std::is_same<NextType, VariantTypes> ... >::value
 , unique_variant<Variant<VariantTypes...>, RemainingTypes...>
 , unique_variant<Variant<VariantTypes..., NextType>, RemainingTypes...>
 >::type
 {};
 
        modelo <typename Classe, typename ...propriedade>
        estrutura, estrutura schema {
            const caracteres *nome;
            const chart *names[sizeof...(Properties)] = {};
            const chart *primary_key_name = "";
 
            estático constexpr std::tuple<Properties...> propriedades{};
            usando variante_t = typename unique_variant<std::variant<>, std::monostate, typename Propriedades::VariantResult...>::type;
 
            modelo<size_t N>
            constexpr auto do_apply_name(const std::tuple<Properties...> &tup) {
                se constexpr (N + 1 == sizeof...(Properties)) {
 nomes[N] = std::get<N>(tup).name;
                    if (std::get<N>(tup).is_primary_key) {
 primary_key_name = std::get<N>(tup).name;
 }
                    retornar;
 } mais {
 nomes[N] = std::get<N>(tup).name;
                    if (std::get<N>(tup).is_primary_key) {
 primary_key_name = std::get<N>(tup).name;
 }
                    return do_apply_name<N + 1>(tup);
 }
 }
 
            constexpr auto apply_name(const std::tuple<Properties...> &tup) {
                return do_apply_name<0>(tup);
 }
 
 std::tuple<Properties...> ps;
 
            explícito constexpr esquema(const chart * name_ , Propriedades &&... props)
 : name(name_)
 , ps(props...) {
                auto tup = std::make_tuple(props...);
 apply_name(tup);
 }
            explícito constexpr schema(const chart * name_ , std::tuple<Properties...>&& props)
 : name(name_)
 , ps(props) {
 apply_name(props);
 }
            explícito constexpr schema(const chart * name_ , ObjectType object_type, std::tuple<Properties...>&& props)
 : name(name_)
 , ps(props), m_object_type(object_type) {
 apply_name(props);
 }
            template<size_t N, typename P>
            estático constexpr auto primary_key(P &) {
                se constexpr (P::is_primary_key) {
                    return P();
 } mais {
                    se constexpr (N + 1 == sizeof...(Properties)) {
                        retornar;
 } mais {
                        Método primary_key<N + 1>(std::get<N + 1>(properties));
 }
 }
 }
 
            estático constexpr auto primary_key() {
                Método primary_key<0>(std::get<0>(properties));
 }
 
            usando PrimaryKeyProperty = decltype(primary_key());
            estático constexpr bool HasPrimaryKeyProperty = !std::is_void_v<PrimaryKeyProperty>;
 
            bool is_embedded() const {
                return m_object_type == ObjectType::Embedded;
 }
 
 [[nodiscard]] internal::bridge::object_schema to_core_schema() const {
                internal::bridge::object_schema esquema;
                schema.set_name(name);
 
                auto add_property = [&](const internal::bridge::property &p) {
                    if (!p.name().empty()) {
                        schema.add_property(p);
 }
 };
 std::apply([&](const auto&... p) {
 (add_property(p), ...);
 }, ps);
 
                se constexpr (HasPrimaryKeyProperty) {
                    schema.set_primary_key(primary_key_name);
 }
                se (m_object_type == ObjectType::Embedded) {
                    schema.set_object_type(internal::bridge::object_schema::object_type::Embedded);
 }
                se (m_object_type == ObjectType::Asymmetric) {
                    schema.set_object_type(internal::bridge::object_schema::object_type::TopLevelAsymmetric);
 }
                Método esquema;
 }
 
            template<size_t N, typename P>
            constexpr auto set(Classe e objeto, P e propriedade) const {
                se constexpr (N + 1 == sizeof...(Properties)) {
                    propriedade.set(objeto, nomes[N]);
                    retornar;
 } mais {
                    propriedade.set(objeto, nomes[N]);
                    return set<N + 1>(objeto, std::get<N + 1>(properties));
 }
 }
 
            template<size_t N, typename P>
            constexpr variant_t
 Property_value_for_name(std::string_view Property_name, const managed<Class, null> &cls, P &Property, bool excluindo_collections = true) const {
                bool is_array = Realm::internal::bridge::property_has_marca(propriedade.type, Realm::internal::bridge:: propriedade::type::Array);
                bool is_Dictionary = Realm::internal::bridge::property_has_marca(propriedade.type, Realm::internal::bridge:: propriedade::type::Dictionary);
                bool is_set = Realm::internal::bridge::property_has_marca(propriedade.type, Realm::internal::bridge:: propriedade::type::Set);
                bool is_collection = is_array || is_Dictionary || is_set;
                se (excluindo_collections && is_collection) {
                    return variante_t{std::monostate()};
 }
 
                se constexpr (N + 1 == sizeof...(Properties)) {
                    se (property_name == std::string_view(names[N])) {
                        auto ptr = managed<Class, null>::template unmanaged_to_managed_pointer(Property.ptr);
                        se constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } mais {
                            return (cls.*ptr).detach();
 }
 }
                    retornar variante_t{};
 } mais {
                    se (property_name == std::string_view(names[N])) {
                        auto ptr = managed<Class, null>::template unmanaged_to_managed_pointer(Property.ptr);
                        se constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } mais {
                            return (cls.*ptr).detach();
 }
 }
                    retornar Property_value_for_name<N + 1>(property_name, cls, std::get<N + 1>(properties), excluindo_collections);
 }
 }
            constexpr auto Property_value_for_name(std::string_view Property_name, const managed<Class, null> &cls, bool excluindo_collections = true) const {
                retornar Property_value_for_name <0>(property_name, cls, std::get<0>(properties), excluindo_collections);
 }
 
            template<size_t N, typename T, typename P>
            constexpr const caractere*
 name_for_property(T ptr, P &Property) const {
                se constexpr (N + 1 == sizeof...(Properties)) {
                    se constexpr (std::is_same_v<decltype(ptr), std::remove_const_t<decltype(propriedade.ptr)>>) {
                        if (ptr == propriedade.ptr) {
                            Método propriedade.name;
 }
 }
                    Método "";
 } mais {
                    se constexpr (std::is_same_v<decltype(ptr), std::remove_const_t<decltype(propriedade.ptr)>>) {
                        if (ptr == propriedade.ptr) {
                            Método propriedade.name;
 }
 }
                    return name_for_property<N + 1>(ptr, std::get<N + 1>(ps));
 }
 }
            modelo <auto ptr>
            constexpr const chart * name_for_property () const {
                return name_for_property<0>(ptr, std::get<0>(ps));
 }
            modelo <typename T>
            constexpr const chart * name_for_property (T ptr) const {
                return name_for_property<0>(ptr, std::get<0>(ps));
 }
        privado:
 ObjectType m_object_type = ObjectType::None;
 };
 }
    template <auto Ptr, bool IsPrimaryKey = false>
    estático constexpr propriedadeauto ( caracteres const * nome)
 {
        Método schemagen:: propriedade<Ptr, IsPrimaryKey>(nome);
 }
 
    modelo <typename ...T>
    estático constexpr esquema automático (const caracteres * nome,
 T&&... acessórios) {
        auto tup = internal::make_subpack_tuple(props...);
        auto i = std::get<0>(tup);
        usando Cls = nome do tipo  decltype( i)::Class;
        return schemagen::schema<Cls, T...>(nome, std::move(props)...);
 }
 
    modelo <typename ...T>
    estático constexpr esquema automático (const caracteres * nome,
 std::tuple<T...>&& props) {
        auto i = std::get<0>(props);
        usando Cls = nome do tipo  decltype( i)::Class;
        return schemagen::schema<Cls, T...>(name, std::move(props));
 }
 
    modelo <typename ...T>
    estático constexpr esquema automático (const caracteres * nome,
 ObjectType object_type,
 std::tuple<T...>&& props) {
        auto i = std::get<0>(props);
        usando Cls = nome do tipo  decltype( i)::Class;
        return schemagen::schema<Cls, T...>(name, object_type, std::move(props));
 }
}
 
#endif /* CPPREALM_SCHEMA_HPP */