meta.h: simplify meta programming helpers

Some (older) compilers have problems with compile-time constants.
This commit simplifies the implementation of the helper classes
in order to improve compiler support, especially be removing the
need of partial template specialisation.

No functional changes.

include/rapidjson/internal/meta.h

@@ -30,51 +30,75 @@ RAPIDJSON_DIAG_OFF(effc++)
 namespace rapidjson {
 namespace internal {
 
-template <int N> struct IntegralC { enum { Value = N }; };
-template <bool Cond> struct BoolType : IntegralC<Cond> {};
-struct TrueType : BoolType<true> {};
-struct FalseType : BoolType<false> {};
 
+///////////////////////////////////////////////////////////////////////////////
+// BoolType, TrueType, FalseType
+//
+template <bool Cond> struct BoolType {
+    static const bool Value = Cond;
+    typedef BoolType Type;
+};
+typedef BoolType<true> TrueType;
+typedef BoolType<false> FalseType;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
+//
+
+template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
+template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
+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 { typedef const T Type; };
+template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
 template <typename T> struct RemoveConst { typedef T Type; };
 template <typename T> struct RemoveConst<const T> { typedef T Type; };
 
-template <bool Condition, typename T1, typename T2> struct SelectIfCond;
-template <typename T1, typename T2> struct SelectIfCond<true,T1,T2> { typedef T1 Type; };
-template <typename T1, typename T2> struct SelectIfCond<false,T1,T2> { typedef T2 Type; };
-
-template <typename Condition, typename T1, typename T2>
-struct SelectIf : SelectIfCond<Condition::Value,T1,T2> {};
-
-template <bool Constify, typename T>
-struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
 
+///////////////////////////////////////////////////////////////////////////////
+// IsSame, IsConst, IsMoreConst, IsPointer
+//
 template <typename T, typename U> struct IsSame : FalseType {};
-template <typename T> struct IsSame<T,T>  : TrueType {};
+template <typename T> struct IsSame<T, T> : TrueType {};
 
 template <typename T> struct IsConst : FalseType {};
 template <typename T> struct IsConst<const T> : TrueType {};
 
+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 {};
 template <typename T> struct IsPointer<T*> : TrueType {};
 
-template <typename CT, typename T>
-struct IsMoreConst {
-    enum { Value =
-        ( IsSame< typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>::Value
-        && ( IsConst<CT>::Value >= IsConst<T>::Value ) )
     };
 };
 
+
 //////////////////////////////////////////////////////////////////////////
 // EnableIf / DisableIf
 //
-template <bool Condition, typename T = void> struct EnableIfCond;
-template <typename T> struct EnableIfCond<true, T> { typedef T Type; };
+template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
 template <typename T> struct EnableIfCond<false, T> { /* empty */ };
 
-template <bool Condition, typename T = void>
-struct DisableIfCond : EnableIfCond<!Condition, T> {};
+template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
+template <typename T> struct DisableIfCond<true, T> { /* empty */ };
 
 template <typename Condition, typename T = void>
 struct EnableIf : EnableIfCond<Condition::Value, T> {};
@@ -83,13 +107,13 @@ template <typename Condition, typename T = void>
 struct DisableIf : DisableIfCond<Condition::Value, T> {};
 
 // SFINAE helpers
-struct SfinaeResultTag {};
-template <typename T> struct RemoveSfinaeFptr {};
-template <typename T> struct RemoveSfinaeFptr<SfinaeResultTag&(*)(T)> { typedef T Type; };
+struct SfinaeTag {};
+template <typename T> struct RemoveSfinaeTag;
+template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
 
 #define RAPIDJSON_REMOVEFPTR_(type) \
-    typename ::rapidjson::internal::RemoveSfinaeFptr \
-        < ::rapidjson::internal::SfinaeResultTag&(*) type>::Type
+    typename ::rapidjson::internal::RemoveSfinaeTag \
+        < ::rapidjson::internal::SfinaeTag&(*) type>::Type
 
 #define RAPIDJSON_ENABLEIF(cond) \
     typename ::rapidjson::internal::EnableIf \