LeechCraft  0.6.70-16373-g319c272718
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 <type_traits>
12 #include <util/sll/typelist.h>
13 #include <util/sll/typegetter.h>
14 
15 namespace LC
16 {
17 namespace Util
18 {
19 namespace oral
20 {
21  struct NoAutogen;
22 
23  template<typename T, typename Concrete>
25  {
26  using value_type = T;
27 
28  T Val_;
29 
30  IndirectHolderBase () = default;
31 
33  : Val_ { val }
34  {
35  }
36 
37  template<typename U = T, typename Sub = typename U::value_type>
39  : Val_ { val }
40  {
41  }
42 
43  Concrete& operator= (T val)
44  {
45  Val_ = val;
46  return static_cast<Concrete&> (*this);
47  }
48 
49  operator value_type () const
50  {
51  return Val_;
52  }
53 
54  const value_type& operator* () const
55  {
56  return Val_;
57  }
58 
59  const value_type* operator-> () const
60  {
61  return &Val_;
62  }
63  };
64 
65  template<typename T, typename... Tags>
66  struct PKey : IndirectHolderBase<T, PKey<T, Tags...>>
67  {
68  using PKey::IndirectHolderBase::IndirectHolderBase;
69  };
70 
71  template<typename T, typename... Args>
72  using PKeyValue_t = typename PKey<T, Args...>::value_type;
73 
74  template<typename T>
75  struct Unique : IndirectHolderBase<T, Unique<T>>
76  {
77  using Unique::IndirectHolderBase::IndirectHolderBase;
78  };
79 
80  template<typename T>
82 
83  template<typename T>
84  struct NotNull : IndirectHolderBase<T, NotNull<T>>
85  {
86  using NotNull::IndirectHolderBase::IndirectHolderBase;
87  };
88 
89  template<typename T>
91 
92  template<typename T>
94 
95  namespace detail
96  {
97  template<typename T>
98  struct IsReferencesTarget : std::false_type {};
99 
100  template<typename U, typename... Tags>
101  struct IsReferencesTarget<PKey<U, Tags...>> : std::true_type {};
102 
103  template<typename U>
104  struct IsReferencesTarget<Unique<U>> : std::true_type {};
105  }
106 
107  template<auto Ptr>
108  struct References : IndirectHolderBase<typename MemberPtrType_t<Ptr>::value_type, References<Ptr>>
109  {
111  static_assert (detail::IsReferencesTarget<member_type>::value, "References<> element must refer to a PKey<> element");
112 
113  using References::IndirectHolderBase::IndirectHolderBase;
114 
115  template<typename T, typename... Tags>
118  {
119  }
120 
121  template<typename T, typename... Tags>
123  {
124  this->Val_ = key;
125  return *this;
126  }
127  };
128 
129  template<auto Ptr>
131 
132  template<size_t... Fields>
133  struct PrimaryKey {};
134 
135  template<size_t... Fields>
136  struct UniqueSubset {};
137 
138  template<typename... Args>
139  using Constraints = Typelist<Args...>;
140 
141  template<auto... Fields>
142  struct Index;
143 
144  template<typename... Args>
145  using Indices = Typelist<Args...>;
146 
147  template<typename T>
148  struct IsIndirect : std::false_type {};
149 
150  template<typename T, typename... Args>
151  struct IsIndirect<PKey<T, Args...>> : std::true_type {};
152 
153  template<typename T>
154  struct IsIndirect<Unique<T>> : std::true_type {};
155 
156  template<typename T>
157  struct IsIndirect<NotNull<T>> : std::true_type {};
158 
159  template<auto Ptr>
160  struct IsIndirect<References<Ptr>> : std::true_type {};
161 
163  {
164  constexpr inline static struct DefaultTag {} Default {};
165  constexpr inline static struct IgnoreTag {} Ignore {};
166 
167  struct Replace
168  {
169  template<auto... Ptrs>
170  struct FieldsType {};
171 
172  template<auto... Ptrs>
173  constexpr inline static FieldsType<Ptrs...> Fields {};
174 
175  constexpr inline static struct PKeyType {} PKey {};
176  };
177  };
178 }
179 }
180 }
const value_type * operator->() const
Definition: oraltypes.h:59
MemberPtrType_t< Ptr > member_type
Definition: oraltypes.h:110
static constexpr FieldsType< Ptrs... > Fields
Definition: oraltypes.h:173
typename PKey< T, Args... >::value_type PKeyValue_t
Definition: oraltypes.h:72
static constexpr struct LC::Util::oral::InsertAction::IgnoreTag Ignore
typename References< Ptr >::value_type ReferencesValue_t
Definition: oraltypes.h:130
MemberTypeType_t< decltype(Ptr)> MemberPtrType_t
Definition: typegetter.h:70
Q_DECL_IMPORT const QString Tags
References & operator=(const PKey< T, Tags... > &key)
Definition: oraltypes.h:122
typename NotNull< T >::value_type NotNullValue_t
Definition: oraltypes.h:90
typename Unique< T >::value_type UniqueValue_t
Definition: oraltypes.h:81
const value_type & operator*() const
Definition: oraltypes.h:54
static constexpr struct LC::Util::oral::InsertAction::DefaultTag Default
References(const PKey< T, Tags... > &key)
Definition: oraltypes.h:116