TrinityCore
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
meta.h
Go to the documentation of this file.
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14 
15 #ifndef RAPIDJSON_INTERNAL_META_H_
16 #define RAPIDJSON_INTERNAL_META_H_
17 
18 #include "../rapidjson.h"
19 
20 #ifdef __GNUC__
21 RAPIDJSON_DIAG_PUSH
22 RAPIDJSON_DIAG_OFF(effc++)
23 #endif
24 #if defined(_MSC_VER)
25 RAPIDJSON_DIAG_PUSH
26 RAPIDJSON_DIAG_OFF(6334)
27 #endif
28 
29 #if RAPIDJSON_HAS_CXX11_TYPETRAITS
30 #include <type_traits>
31 #endif
32 
33 //@cond RAPIDJSON_INTERNAL
35 namespace internal {
36 
37 // Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
38 template <typename T> struct Void { typedef void Type; };
39 
41 // BoolType, TrueType, FalseType
42 //
43 template <bool Cond> struct BoolType {
44  static const bool Value = Cond;
45  typedef BoolType Type;
46 };
47 typedef BoolType<true> TrueType;
48 typedef BoolType<false> FalseType;
49 
50 
52 // SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
53 //
54 
55 template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
56 template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
57 template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
58 template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
59 
60 template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
61 template <> struct AndExprCond<true, true> : TrueType {};
62 template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
63 template <> struct OrExprCond<false, false> : FalseType {};
64 
65 template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
66 template <typename C> struct NotExpr : SelectIf<C,FalseType,TrueType>::Type {};
67 template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
68 template <typename C1, typename C2> struct OrExpr : OrExprCond<C1::Value, C2::Value>::Type {};
69 
70 
72 // AddConst, MaybeAddConst, RemoveConst
73 template <typename T> struct AddConst { typedef const T Type; };
74 template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
75 template <typename T> struct RemoveConst { typedef T Type; };
76 template <typename T> struct RemoveConst<const T> { typedef T Type; };
77 
78 
80 // IsSame, IsConst, IsMoreConst, IsPointer
81 //
82 template <typename T, typename U> struct IsSame : FalseType {};
83 template <typename T> struct IsSame<T, T> : TrueType {};
84 
85 template <typename T> struct IsConst : FalseType {};
86 template <typename T> struct IsConst<const T> : TrueType {};
87 
88 template <typename CT, typename T>
89 struct IsMoreConst
90  : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
91  BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
92 
93 template <typename T> struct IsPointer : FalseType {};
94 template <typename T> struct IsPointer<T*> : TrueType {};
95 
97 // IsBaseOf
98 //
99 #if RAPIDJSON_HAS_CXX11_TYPETRAITS
100 
101 template <typename B, typename D> struct IsBaseOf
102  : BoolType< ::std::is_base_of<B,D>::value> {};
103 
104 #else // simplified version adopted from Boost
105 
106 template<typename B, typename D> struct IsBaseOfImpl {
107  RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
108  RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
109 
110  typedef char (&Yes)[1];
111  typedef char (&No) [2];
112 
113  template <typename T>
114  static Yes Check(const D*, T);
115  static No Check(const B*, int);
116 
117  struct Host {
118  operator const B*() const;
119  operator const D*();
120  };
121 
122  enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
123 };
124 
125 template <typename B, typename D> struct IsBaseOf
126  : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
127 
128 #endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
129 
130 
132 // EnableIf / DisableIf
133 //
134 template <bool Condition, typename T = void> struct EnableIfCond { typedef T Type; };
135 template <typename T> struct EnableIfCond<false, T> { /* empty */ };
136 
137 template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
138 template <typename T> struct DisableIfCond<true, T> { /* empty */ };
139 
140 template <typename Condition, typename T = void>
141 struct EnableIf : EnableIfCond<Condition::Value, T> {};
142 
143 template <typename Condition, typename T = void>
144 struct DisableIf : DisableIfCond<Condition::Value, T> {};
145 
146 // SFINAE helpers
147 struct SfinaeTag {};
148 template <typename T> struct RemoveSfinaeTag;
149 template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
150 
151 #define RAPIDJSON_REMOVEFPTR_(type) \
152  typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
153  < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
154 
155 #define RAPIDJSON_ENABLEIF(cond) \
156  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
157  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
158 
159 #define RAPIDJSON_DISABLEIF(cond) \
160  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
161  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
162 
163 #define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
164  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
165  <RAPIDJSON_REMOVEFPTR_(cond), \
166  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
167 
168 #define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
169  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
170  <RAPIDJSON_REMOVEFPTR_(cond), \
171  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
172 
173 } // namespace internal
175 //@endcond
176 
177 #if defined(__GNUC__) || defined(_MSC_VER)
178 RAPIDJSON_DIAG_POP
179 #endif
180 
181 #endif // RAPIDJSON_INTERNAL_META_H_
char Yes[1]
Definition: format.h:1007
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Definition: rapidjson.h:119
#define RAPIDJSON_STATIC_ASSERT(x)
(Internal) macro to check for conditions at compile-time
Definition: rapidjson.h:375
#define false
Definition: CascPort.h:18
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
Definition: rapidjson.h:116
#define T1
Definition: Crypto_md5.cpp:153
#define true
Definition: CascPort.h:17
#define T2
Definition: Crypto_md5.cpp:154
char No[2]
Definition: format.h:1008
Definition: document.h:390
#define const
Definition: zconf.h:217
Type
Type of JSON value.
Definition: rapidjson.h:642