LeechCraft  0.6.70-15082-g543737046d
Modular cross-platform feature rich live environment.
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 
19 namespace LC
20 {
21 namespace Util
22 {
23 namespace oral
24 {
25  struct NoAutogen;
26 
27  template<typename T, typename Concrete>
28  struct IndirectHolderBase
29  {
30  using value_type = T;
31 
32  T Val_;
33 
34  IndirectHolderBase () = default;
35 
36  IndirectHolderBase (T val)
37  : Val_ { val }
38  {
39  }
40 
41  template<typename U = T, typename Sub = typename U::value_type>
42  IndirectHolderBase (Sub val)
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>
85  using UniqueValue_t = typename Unique<T>::value_type;
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>
137  struct PrimaryKey;
138 
139  template<int... Fields>
140  struct UniqueSubset;
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 
166  struct InsertAction
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>
176  struct FieldsType
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 }
typelist.h
LC::Util::oral::IsIndirect
Definition: oraltypes.h:170
LC::Util::oral::ReferencesValue_t
typename References< Ptr >::value_type ReferencesValue_t
Definition: oraltypes.h:152
LC::Util::oral::References::member_type
MemberPtrType_t< Ptr > member_type
Definition: oraltypes.h:132
LC::Util::oral::InsertAction::Selector_
ActionSelector_t Selector_
Definition: oraltypes.h:218
LC::EF::Tags
const Q_DECL_IMPORT QString Tags
Definition: anconstantsdefs.cpp:28
LC::Util::oral::References::operator=
References & operator=(const PKey< T, Tags... > &key)
Definition: oraltypes.h:144
LC::Util::oral::IndirectHolderBase::Val_
T Val_
Definition: oraltypes.h:50
LC::EditorAction::Replace
@ Replace
Open "Replace" dialog.
LC::Util::oral::References
Definition: oraltypes.h:130
LC::Util::oral::InsertAction::Replace::Fields
static FieldsType< Ptrs... > Fields
Definition: oraltypes.h:200
LC::Util::oral::IndirectHolderBase::IndirectHolderBase
IndirectHolderBase()=default
LC::Util::MemberPtrType_t
MemberTypeType_t< decltype(Ptr)> MemberPtrType_t
Definition: typegetter.h:67
LC::Util::oral::PrimaryKey
Definition: oraltypes.h:155
LC::Util::oral::Index
Definition: oraltypes.h:164
LC::Util::oral::InsertAction::ActionSelector_t
std::variant< DefaultTag, IgnoreTag, Replace > ActionSelector_t
Definition: oraltypes.h:217
LC::Util::oral::UniqueSubset
Definition: oraltypes.h:158
LC::Util::oral::References::References
References(const PKey< T, Tags... > &key)
Definition: oraltypes.h:138
LC::Util::oral::InsertAction::Replace
Definition: oraltypes.h:189
LC::Util::Typelist
Definition: typelist.h:30
LC::Util::oral::IndirectHolderBase::operator=
Concrete & operator=(T val)
Definition: oraltypes.h:65
LC::Util::oral::UniqueValue_t
typename Unique< T >::value_type UniqueValue_t
Definition: oraltypes.h:103
LC::Util::oral::NotNull
Definition: oraltypes.h:106
LC::Util::oral::IndirectHolderBase
Definition: oraltypes.h:46
LC::Util::oral::InsertAction::Replace::PKeyType
Definition: oraltypes.h:203
LC::Util::oral::PKeyValue_t
typename PKey< T, Args... >::value_type PKeyValue_t
Definition: oraltypes.h:94
LC::Util::oral::InsertAction::InsertAction
InsertAction(Tag tag)
Definition: oraltypes.h:221
typegetter.h
LC::Util::oral::PKey
Definition: oraltypes.h:88
LC::Util::oral::NotNullValue_t
typename NotNull< T >::value_type NotNullValue_t
Definition: oraltypes.h:112
LC::Util::oral::InsertAction::Ignore
static struct LC::Util::oral::InsertAction::IgnoreTag Ignore
LC
Definition: constants.h:14
LC::Util::oral::detail::IsReferencesTarget
Definition: oraltypes.h:120
LC::Util::oral::InsertAction::Default
static struct LC::Util::oral::InsertAction::DefaultTag Default
LC::Util::oral::InsertAction
Definition: oraltypes.h:184
LC::Util::oral::IndirectHolderBase::value_type
T value_type
Definition: oraltypes.h:48
LC::Util::oral::Unique
Definition: oraltypes.h:97
LC::Util::oral::InsertAction::Replace::Fields_
QStringList Fields_
Definition: oraltypes.h:191
LC::Util::oral::IndirectHolderBase::operator*
const value_type & operator*() const
Definition: oraltypes.h:76
LC::Util::oral::IndirectHolderBase::operator->
const value_type * operator->() const
Definition: oraltypes.h:81
LC::Util::oral::InsertAction::StaticCount
constexpr static auto StaticCount()
Definition: oraltypes.h:212