schema.hpp

 
//
//저작권 2022 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_SCHEMA_HPP
#define CPPRALM_SCHEMA_HPP
 
#include <cpprealm/link.hpp>
#include <cpprealm/internal/bridge/lnklst.hpp>
#include <cpprealm/internal/bridge/object_schema.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
#include <cpprealm/internal/bridge/table.hpp>
#include <cpprealm/internal/type_info.hpp>
#include <variant>
 
#include <type_traits>
#include <iostream>
 
네임스페이스 영역 {
    열거형 클래스 ObjectType {
 없음,
 TopLevel,
 임베디드,
 비대칭
 };
    네임스페이스 내부 {
        템플릿 <typename T>
        구조체 ptr_type_extractor_base;
        template <typename 결과, typename 클래스>
        구조체 ptr_type_extractor_base<Result Class::*>
 {
            using class_type = Class;
            using member_type = Result;
 };
 
        template <auto T>
        구조체 ptr_type_extractor : ptr_type_extractor_base<decltype(T)> {
 };
 
        template<typename... Typescript>
        constexpr auto make_subpack_tuple(Ts&&... xs)
 {
            return std::tuple<Ts...>(std::forward<Ts>(xs)...);
 }
 
        템플릿 <typename T>
        구조체 지속 형_추출기 {
            Result = T 를 사용 합니다.
 };
 }
 
 
    // 마크: 스키마
    네임스페이스 schemagen {
        템플릿 <auto Ptr, bool IsPrimaryKey = false>
        구조체 속성 {
            using Result = typename internal::persisted_type_extractor<typename internal::ptr_type_extractor<Ptr>::member_type>::Result;
            VariantResult =
 std::conditional_t<std::is_pointer_v<Result>, managed<Result>, Result>;
 
            using Class = typename internal::ptr_type_extractor<Ptr>::class_type;
            static constexpr 자동 ptr = Ptr;
            static constexpr bool is_primary_key = IsPrimaryKey || internal::type_info::is_primary_key<Result>::value;
 internal::bridge::property::type type;
            const char* name = "";
 
            constexpr 속성() : type(internal::type_info::type_info<Result>::type())
 {
 }
            명시적 constexpr 속성(const char* real_name)
 : type(internal::type_info::type_info<Result>::type())
 {
 이름 = real_name;
 }
 
            연산자 internal::bridge:: 속성() const {
                internal::bridge::property 속성(이름, 유형, is_primary_key);
                만약 constexpr (realm::internal::type_info::is_vector<Result>::value) {
                    만약 constexpr (std::is_pointer_v<typename Result::value_type>) {
                        속성.set_object_link(관리되는<std::remove_pointer_t<typename Result::value_type>, oid>::schema.name);
 }
 } other if constexpr (realm::internal::type_info:: is_set<Result>::value) {
                    만약 constexpr (std::is_pointer_v<typename Result::value_type>) {
                        속성.set_object_link(관리되는<std::remove_pointer_t<typename Result::value_type>, oid>::schema.name);
 }
 } other if constexpr (realm ::internal::type_info:: is_map::value )<Result> {
                    만약 constexpr (internal::type_info::is_optional<typename Result::mapped_type>::value) {
                        만약 constexpr (internal::type_info::is_link<typename Result::mapped_type::value_type>::value) {
                            속성.set_object_link(managed<std::remove_pointer_t<typename Result:: mapped_type ::value_type>, oid >:: 스키마.name);
                            속성.set_type(type | internal::bridge::property::type::Nullable);
 }
 } 다른 경우 if constexpr (std::is_pointer_v<typename Result::mapped_type>) {
                        속성.set_object_link(managed<std::remove_pointer_t<typename Result:: mapped_type>, oid >:: 스키마.name);
                        속성.set_type(type | internal::bridge::property::type::Nullable);
 }
 } 다른 경우 if constexpr (std::is_pointer_v<Result>) {
                    속성.set_object_link (관리<유형 이름 std::remove_pointer_t<Result>, oid>::schema.name);
                    속성.set_type(type | internal::bridge::property::type::Nullable);
 } other if constexpr (internal::type_info:: is_backlink<Result>::value) {
                    반환 internal::bridge:: 속성{};
 }
 
                반환 속성;
 }
 };
 
        template <typename T, typename ... types>
        구조체 unique_variant {
            유형 = T 를 사용 합니다.
 };
 
        template <template<typename...> typename Variant, typename... VariantTypes, typename NextType, typename... RemainingTypes>
        구조체 unique_variant<Variant<VariantTypes...> , NextType, RemainingTypes...>
 : std::conditional<
 std::dis Junction< std::is_same<NextType, VariantTypes> ... >::value
 , unique_variant<Variant<VariantTypes...>, RemainingTypes...>
 , unique_variant<Variant<VariantTypes..., NextType>, RemainingTypes...>
 >::type
 {};
 
        템플릿 <typename class, typename 속성>
        구조체 schema {
            const char *name;
            const char *names[sizeof...(Properties)] = {};
            const char *primary_key_name = "";
 
            static constexpr std::tuple<Properties...> properties{};
            using variant_t = typename unique_variant<std::variant<>, std::monostate, typename Properties::VariantResult...>::type;
 
            템플릿<size_t N>
            constexpr auto do_apply_name(const std::tuple<Properties...> &tup) {
                만약 constexpr (N + 1 == sizeof...(Properties)) {
 이름[N] = std::get<N>(tup).name;
                    if (std::get<N>(tup).is_primary_key) {
 primary_key_name = std::get<N>(tup).name;
 }
                    return;
 } 기타 {
 이름[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;
 
            명시적 constexpr schema(const char *name_, 속성 &&... props)
 : name(name_)
 , ps(props...) {
                auto tup = std::make_tuple(props...);
 apply_name(tup);
 }
            명시적 constexpr schema(const char *name_, std::tuple<Properties...>&& props)
 : name(name_)
 , ps(props) {
 apply_name(props);
 }
            명시적 constexpr 스키마(const char *name_, ObjectType object_type, std::tuple<Properties...>&& props)
 : name(name_)
 , ps(props), m_object_type(object_type) {
 apply_name(props);
 }
            템플릿<size_t N, typename P>
            static constexpr 자동 primary_key(P &) {
                만약 constexpr (P::is_primary_key) {
                    반환 P();
 } 기타 {
                    만약 constexpr (N + 1 == sizeof...(Properties)) {
                        return;
 } 기타 {
                        반환 primary_key<N + 1>(std::get<N + 1>(properties));
 }
 }
 }
 
            static constexpr 자동 primary_key() {
                반환 primary_key<0>(std::get<0>(properties));
 }
 
            PrimaryKeyProperty = decltype(primary_key());
            static constexpr bool HasPrimaryKeyProperty = !std::is_oid_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 스키마;
                스키마.set_name(name);
 
                auto add_property = [&](const internal::bridge::property &p) {
                    if (!p.name().empty()) {
                        스키마.add_property(p);
 }
 };
 std:: 적용([&](const auto&... p) {
 (add_property(p), ...);
 }, ps);
 
                만약 constexpr (HasPrimaryKeyProperty) {
                    schema.set_primary_key(primary_key_name);
 }
                if (m_object_type == ObjectType::Embedded) {
                    schema.set_object_type(internal::bridge::object_schema::object_type::Embedded);
 }
                if (m_object_type == ObjectType::Asymmetric) {
                    schema.set_object_type(internal::bridge::object_schema::object_type::TopLevelAsymmetric);
 }
                반환 스키마;
 }
 
            템플릿<size_t N, typename P>
            constexpr auto set(Class &object, P &속성) const {
                만약 constexpr (N + 1 == sizeof...(Properties)) {
                    속성. 설정하다(객체, 이름[N]);
                    return;
 } 기타 {
                    속성. 설정하다(객체, 이름[N]);
                    return 설정하다<N + 1>(객체, std::get<N + 1>(properties));
 }
 }
 
            템플릿<size_t N, typename P>
            constexpr variant_t
 속성 값_for_name(std::string_view 속성 이름, const 관리<클래스, 무효> &cls, P &속성, bool linking_collections = true) const {
                bool is_array = 영역::internal::bridge::property_has_flag(속성.type, 영역::internal::bridge:: 속성::type::Array);
                bool is_dictionary = 영역::internal::bridge::property_has_flag(속성.type, 영역::internal::bridge:: 속성::type::Dictionary);
                bool is_set = 영역::internal::bridge::property_has_flag(속성.type, 영역::internal::bridge:: 속성::type::Set);
                bool is_collection = is_array || is_dictionary || is_set;
                if (제외 컬렉션 && is_collection) {
                    return variant_t{std::monostate()};
 }
 
                만약 constexpr (N + 1 == sizeof...(Properties)) {
                    if (property_name == std::string_view(names[N])) {
                        자동 ptr = managed<클래스, 무효>:: 템플릿 unmanaged_to_managed_pointer(속성.ptr);
                        만약 constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } 기타 {
                            return (cls.*ptr).detach();
 }
 }
                    반환 variant_t{};
 } 기타 {
                    if (property_name == std::string_view(names[N])) {
                        자동 ptr = managed<클래스, 무효>:: 템플릿 unmanaged_to_managed_pointer(속성.ptr);
                        만약 constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } 기타 {
                            return (cls.*ptr).detach();
 }
 }
                    return Property_value_for_name<N + 1>(property_name, cls, std::get<N + 1>(properties), linking_collections);
 }
 }
            constexpr 자동 속성 값_for_name(std::string_view 속성 이름, const managed<클래스, 무효> &cls, bool linking_collections = true) const {
                return Property_value_for_name<0>(property_name, cls, std::get<0>(properties), linking_collections);
 }
 
            템플릿<size_t N, typename T, typename P>
            constexpr const char*
 name_for_property(T ptr, P &속성) const {
                만약 constexpr (N + 1 == sizeof...(Properties)) {
                    만약 constexpr (std::is_same_v<decltype(ptr), std::remove_const_t<decltype(속성.ptr)>>) {
                        if (ptr == 속성.ptr) {
                            반환 속성.name;
 }
 }
                    반환 "";
 } 기타 {
                    만약 constexpr (std::is_same_v<decltype(ptr), std::remove_const_t<decltype(속성.ptr)>>) {
                        if (ptr == 속성.ptr) {
                            반환 속성.name;
 }
 }
                    return name_for_property<N + 1>(ptr, std::get<N + 1>(ps));
 }
 }
            템플릿 <auto ptr>
            constexpr const char* name_for_property() const {
                return name_for_property<0>(ptr, std::get<0>(ps));
 }
            템플릿 <typename T>
            constexpr const char* name_for_property(T ptr) const {
                return name_for_property<0>(ptr, std::get<0>(ps));
 }
        private:
 ObjectType m_object_type = ObjectType::None;
 };
 }
    템플릿 <auto Ptr, bool IsPrimaryKey = false>
    static constexpr auto 속성(const char* name)
 {
        반환 schemagen:: 속성<Ptr, IsPrimaryKey>(name);
 }
 
    템플릿 <typename ...T>
    static constexpr 자동 스키마(const char * 이름,
 T&&... props) {
        auto tup = internal::make_subpack_tuple(props...);
        auto i = std::get<0>(tup);
        using Cls = typename decltype(i)::Class;
        return schemagen::schema<Cls, T...>(name, std::move(props)...);
 }
 
    템플릿 <typename ...T>
    static constexpr 자동 스키마(const char * 이름,
 std::tuple<T...>&& props) {
        auto i = std::get<0>(props);
        using Cls = typename decltype(i)::Class;
        return schemagen:: 스키마<Cls, T...>(name, std::move(props));
 }
 
    템플릿 <typename ...T>
    static constexpr 자동 스키마(const char * 이름,
 ObjectType object_type,
 std::tuple<T...>&& props) {
        auto i = std::get<0>(props);
        using Cls = typename decltype(i)::Class;
        return schemagen:: 스키마<Cls, T...>(name, object_type, std::move(props));
 }
}
 
#endif /* CPPRALM_SCHEMA_HPP */