chromium/third_party/angle/third_party/rapidjson/src/include/rapidjson/internal/meta.h

// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef RAPIDJSON_INTERNAL_META_H_
#define RAPIDJSON_INTERNAL_META_H_

#include "../rapidjson.h"

#ifdef __GNUC__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(…)
#endif

#if defined(_MSC_VER) && !defined(__clang__)
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(6334)
#endif

#if RAPIDJSON_HAS_CXX11_TYPETRAITS
#include <type_traits>
#endif

//@cond RAPIDJSON_INTERNAL
RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
template <typename T> struct Void { … };

///////////////////////////////////////////////////////////////////////////////
// BoolType, TrueType, FalseType
//
template <bool Cond> struct BoolType { … };
TrueType;
FalseType;


///////////////////////////////////////////////////////////////////////////////
// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
//

template <bool C> struct SelectIfImpl { … };
template <> struct SelectIfImpl<false> { … };
template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> { … };
template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> { … };

template <bool Cond1, bool Cond2> struct AndExprCond : FalseType { … };
template <> struct AndExprCond<true, true> : TrueType { … };
template <bool Cond1, bool Cond2> struct OrExprCond : TrueType { … };
template <> struct OrExprCond<false, false> : FalseType { … };

template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type { … };
template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type { … };
template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type { … };
template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type { … };


///////////////////////////////////////////////////////////////////////////////
// AddConst, MaybeAddConst, RemoveConst
template <typename T> struct AddConst { … };
template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> { … };
template <typename T> struct RemoveConst { … };
RemoveConst<const T>;


///////////////////////////////////////////////////////////////////////////////
// IsSame, IsConst, IsMoreConst, IsPointer
//
template <typename T, typename U> struct IsSame : FalseType { … };
IsSame<T, T>;

template <typename T> struct IsConst : FalseType { … };
IsConst<const T>;

template <typename CT, typename T>
struct IsMoreConst
    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type { … };

template <typename T> struct IsPointer : FalseType { … };
IsPointer<T *>;

///////////////////////////////////////////////////////////////////////////////
// IsBaseOf
//
#if RAPIDJSON_HAS_CXX11_TYPETRAITS

template <typename B, typename D> struct IsBaseOf
    : BoolType< ::std::is_base_of<B,D>::value> {};

#else // simplified version adopted from Boost

template<typename B, typename D> struct IsBaseOfImpl { … };

template <typename B, typename D> struct IsBaseOf
    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type { … };

#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS


//////////////////////////////////////////////////////////////////////////
// EnableIf / DisableIf
//
template <bool Condition, typename T = void> struct EnableIfCond  { … };
EnableIfCond<false, T>;

template <bool Condition, typename T = void> struct DisableIfCond { … };
DisableIfCond<true, T>;

template <typename Condition, typename T = void>
struct EnableIf : EnableIfCond<Condition::Value, T> { … };

template <typename Condition, typename T = void>
struct DisableIf : DisableIfCond<Condition::Value, T> { … };

// SFINAE helpers
struct SfinaeTag { … };
template <typename T> struct RemoveSfinaeTag;
RemoveSfinaeTag<SfinaeTag &(*)(T)>;

#define RAPIDJSON_REMOVEFPTR_(type) …

#define RAPIDJSON_ENABLEIF(cond) …

#define RAPIDJSON_DISABLEIF(cond) …

#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) …

#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) …

} // namespace internal
RAPIDJSON_NAMESPACE_END
//@endcond

#if defined(_MSC_VER) && !defined(__clang__)
RAPIDJSON_DIAG_POP
#endif

#ifdef __GNUC__
RAPIDJSON_DIAG_POP
#endif

#endif // RAPIDJSON_INTERNAL_META_H_