schema.hpp

 
//
// © 2022 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_SCHEMA_HPP
CPREALM_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 {
なし、
トップレベル、
埋め込み、
非対称
 };
    名前空間内部 {
        テンプレート< typename T>
        構造体 ptr_type_extractor_base 、
        テンプレート< typename Result、 typename Class>
        構造体 ptr_type_extractor_base <Result Class::*>
 {
            クラス_type = クラスを使用する。
            server_type = 結果を使用する
 };
 
        template <auto T>
        構造体 ptr_type_extractor : ptr_type_extractor_base <decltype(T)> {
 };
 
        テンプレート< typename ... Typescript >
        constexpr 自動create_suback_tune(Ts & & ... xs)
 {
            return std::turple=Ts...==============================================================<Ts...><Ts>
 }
 
        テンプレート< typename T>
        構造体 exists_type_extractor {
            結果 = Tを使用する
 };
 }
 
 
    // MARK: schema
    namespace schemagen {
        テンプレート< auto Ptr, bool IsPrimaryKey =false>
        構造体 プロパティ{
            結果 = typename internal::persed_type_extractor<typename<Ptr> internal::ptr_type_extractor[Ptr]::member_type > ::Result
            VaultResult =を使用する
std::条件付き_t=std:: is_pointer_v<Result> <Result>==Result===================================================================
 
            クラス = typename internal::ptr_type_extractor<Ptr> ::Class_type を使用し ます
            静的 constexpr auto ptr = Ptr;
            静的 constexpr <Result>ブール値 is_primary_key = IsPrimaryKey || internal::type_info::is_primary_key=Result==value===================================================
 internal::bridge::property::type type
            制約 Char * name = "" ,
 
            constexpr プロパティ () : type( internal::type_info::type_info[Result]::type<Result> ()
 {
 }
            explicit constexpr プロパティ（ const Chart * real_name ）
: type( internal::type_info::type_info[Result]::type<Result> ()
 {
 name =natural_name
 }
 
            演算子 internal::bridge::property () const {
                internal::bridge::property プロパティ（名前、タイプ、is_primary_key）
                場合 Constexpr （ Realm:: internal::type_info::is_vector[Result]::value<Result> ）{
                    場合 constexpr (std::is_pointer_v{typename Result::value_type>)<typename Result::value_type> {
                        プロパティ.set_object_link(マネージド<std::remove_pointer_t=typename 結果:: value_type >、null >::schema.name）
 }
 }以外の場合（realm:: internal:: type_info ::is_set<Result>::value ）{{
                    場合 constexpr (std::is_pointer_v{typename Result::value_type>)<typename Result::value_type> {
                        プロパティ.set_object_link(マネージド<std::remove_pointer_t=typename 結果:: value_type >、null >::schema.name）
 }
 }以外の場合（realm:: internal:: type_info ::is_map<Result>::value ）{{
                    場合 Constexpr （ internal::type_info::is_optional[typename]<typename Result::mapped_type> 結果::mapped_type>::value ）{{
                        場合 Constexpr （ internal::type_info::is_link=typename<typename Result::mapped_type::value_type> Result::mapped_type::value_type>::value ）{
                            プロパティ.set_object_link(マネージド<std::remove_pointer_t=typename 結果::mapped_type:: value_type >、valid >::schema.name)
                            プロパティ.set_type(type | internal::bridge::property::type::Nullable）
 }
} } その他の 場合<typename Result::mapped_type>
                        プロパティ.set_object_link(マネージド<std::remove_pointer_t=typename 結果::mapped_type>、無効化された >::schema.name）
                        プロパティ.set_type(type | internal::bridge::property::type::Nullable）
 }
} の 場合 （ std:: is_pointer_v<Result> ）{{
                    プロパティ .set_object_link ( マネージド < タイプ名std::remove_pointer_t<Result>、null >:: schema.name ）
                    プロパティ.set_type(type | internal::bridge::property::type::Nullable）
} 以外の 場合 （ internal:: type_info ::is_backlink=Result=:value<Result> ）{{
                    return internal::bridge::property {}
 }
 
                return プロパティ、
 }
 };
 
        テンプレート< typename T, typename ... Types>
        構造体 unique_variant {
            タイプ = Tを使用しており、
 };
 
        テンプレート<テンプレート<型名...>型名Vault、型名... ValianTypes、型名NextType、型名... RemainingTypes>
        構造体 unique_variant <Valian[ValianTypes...]><VariantTypes...> 、NextType、RemainingTypes...>
 : std::条件付き=
 std::dis MongoDB::is_sample[NextType, VariantTypes]> ... >::value
、<VariantTypes...> unique_variant{Valian}、RemainingTypes...>
 、 unique_variant[Valian[VariantTypes...]、NextType>、RemainingTypes...>
 >::type
 {};
 
        テンプレート< typenameクラス、 typename ...Properties>
        構造体 schema {
            制約 シャード*name
            制約 Char * names [ ...(Properties)] = {}
            制約 char *primary_key_name = "" ,
 
            静的 constexpr std::true[Properties...]><Properties...> properties{}
            を使用することで、variant_t = typename unique_variant[std::variant[]> 、std::mongostat、型名プロパティを使用します::VaultResult...>::type
 
            template<size_t N>
            constexpr 自動do_apply_name( const std::turple<Properties...> &tup) {
                場合 Constexpr (N + 1 ==================================================
 name[N] = std::get<N>(tup).name
                    の場合（std::get<N>(tup).is_primary_key) {
 primary_key_name=std::get<N>(tup).name
 }
                    return;
 } else {
 name[N] = std::get<N>(tup).name
                    の場合（std::get<N>(tup).is_primary_key) {
 primary_key_name=std::get<N>(tup).name
 }
                    do_apply_name <N + 1 >（tup）を返す
 }
 }
 
            constexpr auto apply_name( const std::true=``Properties...><Properties...> &tup) {
                return do_apply_name<0>(tup);
 }
 
 std::turple<Properties...>ps
 
            explicit constexpr スキーマ（ const char *name_、Properties &... props）
 : name(name_)
 , ps(props...) {
                自動tup = std::take_turple(props...)
 apply_name(tup)
 }
            explicit constexpr スキーマ （ const char *name_, std::turple=Properties...>=================================================<Properties...>
 : name(name_)
 , ps(props) {
 apply_name(props)
 }
            explicit constexpr スキーマ （ const char *name_、ObjectType object_type、std::turple=Properties...>=================================<Properties...>
 : name(name_)
 、ps(props)、m_object_type(object_type) {
 apply_name(props)
 }
            テンプレート< size_t N、 typename P>
            静的 constexpr auto プライマリ_キー（P &）{
                場合 constexpr （P::is_primary_key）{{
                    P() を返す
 } else {
                    場合 Constexpr (N + 1 ==================================================
                        return;
 } else {
                        return プライマリ_key< N + 1 > （std::get< N + 1 >（properties））
 }
 }
 }
 
            静的 constexpr auto プライマリ_キー（）{
                return プライマリ_key < 0 > （std::get< 0 >（properties））
 }
 
            PrimaryKeyProperty = Decltype （ primary_key （）） を使用する ため
            静的 constexpr bool HasPrimaryKeyProperty = !std::is_voice_v=PrimaryKeyProperty===================================<PrimaryKeyProperty>
 
            bool is_ embedded() Const {
                return m_object_type == ObjectType::埋め込み 。
 }
 
 [[nodiscard]] internal::bridge::object_schema to_core_schema() const {
                internal::bridge::object_schema schema;
                スキーマ.set_name(name)
 
                autoadd_property = [+]( const internal::bridge::property &p) {
                    場合（!p.name(). empty()) {
                        スキーマ.add_property(p)
 }
 };
 std::apply([+]( const auto &...p) {
 (add_property(p), ...)#
 }, ps);
 
                場合 constexpr (HasPrimaryKeyProperty) {
                    スキーマ.set_primary_key(primary_key_name)
 }
                ( m_object_type == ObjectType::埋め込み) {
                    スキーマ.set_object_type(ternal::bridge::object_schema::object_type::埋め込み)
 }
                （ m_object_type == ObjectType::Ametric）{
                    スキーマ.set_object_type( internal::bridge::object_schema::object_type::TopLevelAmetric)
 }
                return schema;
 }
 
            テンプレート< size_t N、 typename P>
            constexpr 自動セット（クラスとオブジェクト、P &プロパティ）のコンフィギュレーション{
                場合 Constexpr (N + 1 ==================================================
                    プロパティ.set(オブジェクト, name[N]）#
                    return;
 } else {
                    プロパティ.set(オブジェクト, name[N]）#
                    return set<N + 1 >( object 、std::get<N + 1 >(properties)) を返します。
 }
 }
 
            テンプレート< size_t N、 typename P>
            constexpr variant_t
properties_value_for_name (std:: string_view プロパティ _名前、 const Managed <Class、 oidc
                ブール値::内部::bridge::property_has_フラグ(プロパティ.type, Realm:: internal::bridge::property::type::Array）
                ブール値::内部::bridge::property_has_フラグ(プロパティ.type, 邦土::内部::bridge::property::type::Dictionary）
                ブール値::内部::bridge::property_has_フラグ(プロパティ.type, 邦土::内部::bridge::property::type::Set）
                ブールis_collection = is_array|| is_Dictionary|| is_set
                （_collections を除外し、かつ is_collection の場合）{
                    return_t {std::mongostat()} の結果を返す
 }
 
                場合 Constexpr (N + 1 ==================================================
                    （property_name == std:: string_view (names[N])) {
                        auto -ptr = Managed_to_managed_pointer (properties .ptr )
                        場合 constexpr (std::is_pointer_v{typename<typename P::Result> P::Result>) {
                            return (cls.*ptr);
 } else {
                            return (cls.*ptr).detach();
 }
 }
                    return variant_t{};
 } else {
                    （property_name == std:: string_view (names[N])) {
                        auto -ptr = Managed_to_managed_pointer (properties .ptr )
                        場合 constexpr (std::is_pointer_v{typename<typename P::Result> P::Result>) {
                            return (cls.*ptr);
 } else {
                            return (cls.*ptr).detach();
 }
 }
                    return properties_value_for_name<N + 1 >（property_name、cls、std::get< N + 1 >（properties）、除外します_コレクション）。
 }
 }
            constexpr auto properties_value_for_name(std:: string_view プロパティ _name 、 const Managed は 、管理対象 の を
                return properties_value_for_name< 0 >(property_name、cls、std::get< 0 >(properties)、オブジェクト コレクションを除く）。
 }
 
            テンプレート< size_t N, typename T, typename P>
            constexpr 制約 チャート*
 name_for_property (T ptr, P & properties ) const {
                場合 Constexpr (N + 1 ==================================================
                    場合 constexpr （std::is_sume_v< Decltype （ptr）、std::remove_const_t< Decltype （properties .ptr ）>） {
                        （ptr == properties .ptr ）{
                            return プロパティ.name
 }
 }
                    return ""
 } else {
                    場合 constexpr （std::is_sume_v< Decltype （ptr）、std::remove_const_t< Decltype （properties .ptr ）>） {
                        （ptr == properties .ptr ）{
                            return プロパティ.name
 }
 }
                    name_for_property <N + 1 >(ptr, std::get<N + 1 >(ps)) を返します。
 }
 }
            template <auto ptr>
            constexpr 制約 チャート * name_for_property () const {
                return name_for_property< 0 >(ptr, std::get 0 >(ps)) を返します。
 }
            テンプレート< typename T>
            constexpr 制約 チャート * 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>
    静的 constexpr 自動プロパティ（ const char * name）
 {
        return schemagen::property<Ptr, IsPrimaryKey> （名前）
 }
 
    テンプレート< typename ...T>
    静的 constexpr 自動スキーマ( const char * name,
 T &... プロパティ）{{
        自動tup = internal::作成_サブスクライブ_tune(props...)
        auto i = std::get<0>(tup);
        Clients = typename Decltype (i)::Class を使用し 、
        スキーマを返すには以下を行います。
 }
 
    テンプレート< typename ...T>
    静的 constexpr 自動スキーマ( const char * name,
<T...>
        auto i = std::get<0>(props);
        Clients = typename Decltype (i)::Class を使用し 、
        スキーマを返す:::schema[Cls, T...>（name, std::move(props)）]
 }
 
    テンプレート< typename ...T>
    静的 constexpr 自動スキーマ( const char * name,
 ObjectType object_type,
<T...>
        auto i = std::get<0>(props);
        Clients = typename Decltype (i)::Class を使用し 、
        スキーマを返すには、::schema<Cls, T...>(name, object_type, std::move(props)) を返します。
 }
 }
 
#endif /* CPPrealM_SCHEMA_HPP */