LeechCraft 0.6.70-14794-g33744ae6ce
Modular cross-platform feature rich live environment.
Loading...
Searching...
No Matches
oraltypes.h
Go to the documentation of this file.
1/**********************************************************************
2 * LeechCraft - modular cross-platform feature rich internet client.
3 * Copyright (C) 2006-2014 Georg Rudoy
4 *
5 * Distributed under the Boost Software License, Version 1.0.
6 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
7 **********************************************************************/
8
9#pragma once
10
11#include <variant>
12#include <type_traits>
13#include <boost/fusion/include/at_c.hpp>
14#include <boost/fusion/adapted/struct/adapt_struct.hpp>
15#include <boost/fusion/include/adapt_struct.hpp>
16#include <util/sll/typelist.h>
17#include <util/sll/typegetter.h>
18
19namespace LC
20{
21namespace Util
22{
23namespace oral
24{
25 struct NoAutogen;
26
27 template<typename T, typename Concrete>
29 {
30 using value_type = T;
31
33
34 IndirectHolderBase () = default;
35
37 : Val_ { val }
38 {
39 }
40
41 template<typename U = T, typename Sub = typename U::value_type>
43 : Val_ { val }
44 {
45 }
46
47 Concrete& operator= (T val)
48 {
49 Val_ = val;
50 return static_cast<Concrete&> (*this);
51 }
52
53 operator value_type () const
54 {
55 return Val_;
56 }
57
58 const value_type& operator* () const
59 {
60 return Val_;
61 }
62
63 const value_type* operator-> () const
64 {
65 return &Val_;
66 }
67 };
68
69 template<typename T, typename... Tags>
70 struct PKey : IndirectHolderBase<T, PKey<T, Tags...>>
71 {
72 using PKey::IndirectHolderBase::IndirectHolderBase;
73 };
74
75 template<typename T, typename... Args>
76 using PKeyValue_t = typename PKey<T, Args...>::value_type;
77
78 template<typename T>
79 struct Unique : IndirectHolderBase<T, Unique<T>>
80 {
81 using Unique::IndirectHolderBase::IndirectHolderBase;
82 };
83
84 template<typename T>
86
87 template<typename T>
88 struct NotNull : IndirectHolderBase<T, NotNull<T>>
89 {
90 using NotNull::IndirectHolderBase::IndirectHolderBase;
91 };
92
93 template<typename T>
95
96 template<typename T>
98
99 namespace detail
100 {
101 template<typename T>
102 struct IsReferencesTarget : std::false_type {};
103
104 template<typename U, typename... Tags>
105 struct IsReferencesTarget<PKey<U, Tags...>> : std::true_type {};
106
107 template<typename U>
108 struct IsReferencesTarget<Unique<U>> : std::true_type {};
109 }
110
111 template<auto Ptr>
112 struct References : IndirectHolderBase<typename MemberPtrType_t<Ptr>::value_type, References<Ptr>>
113 {
115 static_assert (detail::IsReferencesTarget<member_type>::value, "References<> element must refer to a PKey<> element");
116
117 using References::IndirectHolderBase::IndirectHolderBase;
118
119 template<typename T, typename... Tags>
122 {
123 }
124
125 template<typename T, typename... Tags>
127 {
128 this->Val_ = key;
129 return *this;
130 }
131 };
132
133 template<auto Ptr>
135
136 template<int... Fields>
138
139 template<int... Fields>
141
142 template<typename... Args>
143 using Constraints = Typelist<Args...>;
144
145 template<auto... Fields>
146 struct Index;
147
148 template<typename... Args>
149 using Indices = Typelist<Args...>;
150
151 template<typename T>
152 struct IsIndirect : std::false_type {};
153
154 template<typename T, typename... Args>
155 struct IsIndirect<PKey<T, Args...>> : std::true_type {};
156
157 template<typename T>
158 struct IsIndirect<Unique<T>> : std::true_type {};
159
160 template<typename T>
161 struct IsIndirect<NotNull<T>> : std::true_type {};
162
163 template<auto Ptr>
164 struct IsIndirect<References<Ptr>> : std::true_type {};
165
167 {
168 inline static struct DefaultTag {} Default;
169 inline static struct IgnoreTag {} Ignore;
170
171 struct Replace
172 {
173 QStringList Fields_;
174
175 template<auto... Ptrs>
177 {
178 operator InsertAction::Replace () const;
179 };
180
181 template<auto... Ptrs>
182 inline static FieldsType<Ptrs...> Fields {};
183
184 template<typename Seq>
185 struct PKeyType
186 {
187 operator InsertAction::Replace () const;
188 };
189
190 template<typename Seq>
191 inline static PKeyType<Seq> PKey {};
192 };
193
194 constexpr static auto StaticCount ()
195 {
196 return 2;
197 }
198
199 using ActionSelector_t = std::variant<DefaultTag, IgnoreTag, Replace>;
201
202 template<typename Tag>
203 InsertAction (Tag tag)
204 : Selector_ { tag }
205 {
206 }
207 };
208}
209}
210}
typename NotNull< T >::value_type NotNullValue_t
Definition: oraltypes.h:94
typename Unique< T >::value_type UniqueValue_t
Definition: oraltypes.h:85
typename References< Ptr >::value_type ReferencesValue_t
Definition: oraltypes.h:134
typename PKey< T, Args... >::value_type PKeyValue_t
Definition: oraltypes.h:76
MemberTypeType_t< decltype(Ptr)> MemberPtrType_t
Definition: typegetter.h:61
Definition: constants.h:15
const value_type * operator->() const
Definition: oraltypes.h:63
const value_type & operator*() const
Definition: oraltypes.h:58
static FieldsType< Ptrs... > Fields
Definition: oraltypes.h:182
static struct LC::Util::oral::InsertAction::IgnoreTag Ignore
std::variant< DefaultTag, IgnoreTag, Replace > ActionSelector_t
Definition: oraltypes.h:199
ActionSelector_t Selector_
Definition: oraltypes.h:200
static constexpr auto StaticCount()
Definition: oraltypes.h:194
static struct LC::Util::oral::InsertAction::DefaultTag Default
References(const PKey< T, Tags... > &key)
Definition: oraltypes.h:120
MemberPtrType_t< Ptr > member_type
Definition: oraltypes.h:114
References & operator=(const PKey< T, Tags... > &key)
Definition: oraltypes.h:126