schema.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#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 <cpprealm/internal/bridge/realm.hpp>
#include <cpprealm/internal/bridge/table.hpp>
#include <cpprealm/internal/type_info.hpp>
#include <variant>
 
#include <type_traits>
#include <iostream>
 
命名空间域 {
    enum class ObjectType {
无，
 TopLevel，
嵌入式，
不对称
 }；
    命名空间内部 {
        template < typename T>
        struct ptr_type_extractor_base ;
        template < typename Result, typename Class>
        struct ptr_type_extractor_base <Result Class::*>
 {
            using class_type = Class;
            using member_type = Result;
 }；
 
        template <auto T>
        struct 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)...);
 }
 
        template < typename T>
        struct persisted_type_extractor {
            using Result = T;
 }；
 }
 
 
    // MARK: schema
    命名空间schemagen {
        template <auto Ptr, bool IsPrimaryKey = false>
        struct 属性{
            using Result = typenameinternal ::persisted_type_extractor<typenameinternal::ptr_type_extractor<Ptr>::member_type >::Result;
            using VariantResult =
 std::conditional_t<std::is_pointer_v<Result>, 托管<Result> , Result>;
 
            using Class = typenameInternal ::ptr_type_extractor<Ptr>::class_type ；
            静态 constexpr auto ptr = Ptr;
            静态 constexpr bool is_primary_key = IsPrimaryKey || Internal::type_info::is_primary_key<Result>::value ；
 internal::bridge::property::type type；
            const char * name = "" ;
 
            constexpr property () : type( internal::type_info::type_info<Result>::type ())
 {
 }
            显式 constexpr 属性( const char *actual_name)
 : type( internal::type_info::type_info<Result>::type ())
 {
 name =actual_name；
 }
 
            运算符 inside::bridge:: 属性 () const {
                inside::bridge::property property (name, type, is_primary_key);
                if constexpr ( realm::internal::type_info::is_vector<Result>::value ) {
                    if constexpr (std::is_pointer_v<typename Result::value_type>) {
                        property .set_object_link( managed <std::remove_pointer_t<typename Result::value_type>, void >::schema.name);
 }
 } else if constexpr ( realm::internal::type_info::is_set<Result>::value ) {
                    if constexpr (std::is_pointer_v<typename Result::value_type>) {
                        property .set_object_link( managed <std::remove_pointer_t<typename Result::value_type>, void >::schema.name);
 }
 } else if constexpr ( 域::internal::type_info::is_map<Result>::value ) {
                    if constexpr ( Internal::type_info::is_Optional<typename Result::mapped_type>::value ) {
                        if constexpr ( internal::type_info::is_link<typename Result::mapped_type::value_type>::value ) {
                            属性 .set_object_link( 托管 <std::remove_pointer_t<typename Result::mapped_type::value_type>, void >:: 模式.name);
                            property .set_type(type | Internal::bridge::property::type::Nullable);
 }
 } else if constexpr (std::is_pointer_v<typename Result::mapped_type>) {
                        属性 .set_object_link( 托管 <std::remove_pointer_t<typename Result::mapped_type>, void >:: 模式.name);
                        property .set_type(type | Internal::bridge::property::type::Nullable);
 }
 } else if constexpr (std::is_pointer_v<Result>) {
                    property .set_object_link( managed < typename std::remove_pointer_t<Result>, void >::schema.name);
                    property .set_type(type | Internal::bridge::property::type::Nullable);
 } else if constexpr ( internal::type_info::is_backlink<Result>::value ) {
                    return inside::bridge:: 属性 {}；
 }
 
                return 属性；
 }
 }；
 
        template < typename T, typename ... Types>
        struct unique_variant {
            using type = T;
 }；
 
        template < template < typename ...> typename Variant, typename ... VariantTypes, typename NextType, typename ... RemainingTypes>
        struct unique_variant <Variant<VariantTypes...> , NextType, RemainingTypes...>
 : std::conditional<
 std::disjunction< std::is_same<NextType, VariantTypes> ... >::value
 , unique_variant<Variant<VariantTypes...>, RemainingTypes...>
 , unique_variant<Variant<VariantTypes..., NextType>, RemainingTypes...>
 >::type
 {};
 
        template < typename Class, typename 属性>
        struct schema {
            const char *name;
            const char *names[ sizeof ...(Properties)] = {};
            const char *primary_key_name = "" ;
 
            静态 constexpr std::tuple<Properties...> properties{};
            usingvariant_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) {
                if constexpr (N + 1 == sizeof ...(Properties)) {
 names[N] = std::get<N>(tup).name;
                    if (std::get<N>(tup).is_primary_key) {
 primary_key_name = std::get<N>(tup).name;
 }
                    return ;
 } else {
 names[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_, Properties &&... 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);
 }
            template < size_t N, typename P>
            静态 constexpr auto primary_key (P &) {
                if constexpr (P::is_primary_key) {
                    return P();
 } else {
                    if constexpr (N + 1 == sizeof ...(Properties)) {
                        return ;
 } else {
                        return Primary_key<N + 1 > (std::get<N + 1 >(properties));
 }
 }
 }
 
            静态 constexpr auto primary_key () {
                return primary_key< 0 > (std::get< 0 >(properties));
 }
 
            using PrimaryKeyProperty = decltype ( primary_key ());
            静态 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 {
                inside::bridge::object_schema schema ；
                模式 .set_name(name);
 
                auto add_property = [&]( const inside ::bridge::property &p) {
                    if (!p.name().empty()) {
                        模式 .add_property(p);
 }
 }；
 std:: 应用([&]( const auto &... p) {
 (add_property(p), ...);
 }, ps);
 
                if 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);
 }
                return schema ；
 }
 
            template < size_t N, typename P>
            constexpr auto set(Class & object , P & property ) const {
                if constexpr (N + 1 == sizeof ...(Properties)) {
                    属性。设立(对象, 名称[N]);
                    return ;
 } else {
                    属性。设立(对象, 名称[N]);
                    return 设立<N + 1 >( 对象 , 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, void> &cls, P & property , bool exclusive_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 (excluded_collections && is_collection) {
                    returnvariant_t{std:: monostate ()};
 }
 
                if constexpr (N + 1 == sizeof ...(Properties)) {
                    if (property_name == std::string_view(names[N])) {
                        auto ptr = Managed<Class, void>::template unmanaged_to_managed_pointer( property .ptr);
                        if constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } else {
                            return (cls.*ptr).detach();
 }
 }
                    returnvariant_t {};
 } else {
                    if (property_name == std::string_view(names[N])) {
                        auto ptr = Managed<Class, void>::template unmanaged_to_managed_pointer( property .ptr);
                        if constexpr (std::is_pointer_v<typename P::Result>) {
                            return (cls.*ptr);
 } else {
                            return (cls.*ptr).detach();
 }
 }
                    return property_value_for_name<N + 1 >(property_name, cls, std::get<N + 1 >(properties), exclusive_collections);
 }
 }
            constexpr auto property_value_for_name(std::string_view property_name, const 托管<Class, void> &cls, bool execution_collections = true ) const {
                return property_value_for_name< 0 >(property_name, cls, std::get< 0 >(properties), exclusive_collections);
 }
 
            template < size_t N, typename T, typename P>
            constexpr const char *
 name_for_property(T ptr, P & property ) const {
                if constexpr (N + 1 == sizeof ...(Properties)) {
                    if constexpr (std::is_same_v< decltype (ptr), std::remove_const_t< decltype ( 属性 .ptr)>>) {
                        if (ptr == property .ptr) {
                            return 属性.name;
 }
 }
                    return "" ;
 } else {
                    if constexpr (std::is_same_v< decltype (ptr), std::remove_const_t< decltype ( 属性 .ptr)>>) {
                        if (ptr == property .ptr) {
                            return 属性.name;
 }
 }
                    return name_for_property<N + 1 >(ptr, std::get<N + 1 >(ps));
 }
 }
            template <auto ptr>
            constexpr const char * name_for_property() const {
                return name_for_property< 0 >(ptr, std::get< 0 >(ps));
 }
            template < 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;
 }；
章
    template <auto Ptr, bool IsPrimaryKey = false>
    静态 constexpr auto属性( const char * name)
 {
        return schemagen:: 属性<Ptr, IsPrimaryKey> (name);
 }
 
    template < typename ...T>
    静态 constexpr auto 模式( const char * name,
 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)...);
 }
 
    template < typename ...T>
    静态 constexpr auto 模式( const char * name,
 std::tuple<T...>&& props) {
        auto i = std::get< 0 >(props);
        using Cls = typename decltype (i)::Class;
        return schemagen:: 模式<Cls, T...>(name, std::move(props));
 }
 
    template < typename ...T>
    静态 constexpr auto 模式( const char * name,
 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 /* CPPREALM_SCHEMA_HPP */