forked from OctaForge/libostd
rename IntegralConstant to Constant
This commit is contained in:
parent
5237c60dfa
commit
9e4d475488
|
@ -77,7 +77,7 @@ struct Array {
|
|||
};
|
||||
|
||||
template<typename T, Size N>
|
||||
struct TupleSize<Array<T, N>>: IntegralConstant<Size, N> {};
|
||||
struct TupleSize<Array<T, N>>: Constant<Size, N> {};
|
||||
|
||||
template<Size I, typename T, Size N>
|
||||
struct TupleElementBase<I, Array<T, N>> {
|
||||
|
|
|
@ -143,7 +143,7 @@ public:
|
|||
};
|
||||
|
||||
template<typename ...T> struct TupleSize<detail::TupleTypes<T...>>:
|
||||
IntegralConstant<Size, sizeof...(T)> {};
|
||||
Constant<Size, sizeof...(T)> {};
|
||||
|
||||
template<typename ...T> struct IsTupleLike<detail::TupleTypes<T...>>: True {};
|
||||
|
||||
|
@ -185,7 +185,7 @@ namespace detail {
|
|||
|
||||
template<typename T, typename ...TT, typename U, typename ...UU>
|
||||
struct TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
|
||||
IntegralConstant<bool, IsConvertible<T, U> &&
|
||||
Constant<bool, IsConvertible<T, U> &&
|
||||
TupleConvertibleBase<TupleTypes<TT...>,
|
||||
TupleTypes<UU...>>::value> {};
|
||||
|
||||
|
@ -218,7 +218,7 @@ namespace detail {
|
|||
|
||||
template<typename T, typename ...TT, typename U, typename ...UU>
|
||||
struct TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
|
||||
IntegralConstant<bool, IsConstructible<U, T> &&
|
||||
Constant<bool, IsConstructible<U, T> &&
|
||||
TupleConstructibleBase<TupleTypes<TT...>,
|
||||
TupleTypes<UU...>>::value> {};
|
||||
|
||||
|
@ -251,7 +251,7 @@ namespace detail {
|
|||
|
||||
template<typename T, typename ...TT, typename U, typename ...UU>
|
||||
struct TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
|
||||
IntegralConstant<bool, IsAssignable<U &, T> &&
|
||||
Constant<bool, IsAssignable<U &, T> &&
|
||||
TupleAssignableBase<TupleTypes<TT...>,
|
||||
TupleTypes<UU...>>::value> {};
|
||||
|
||||
|
|
|
@ -208,7 +208,7 @@ namespace detail {
|
|||
template<typename T>
|
||||
static char ptr_test(typename T::Pointer * = 0);
|
||||
|
||||
template<typename T> struct HasPtr: IntegralConstant<bool,
|
||||
template<typename T> struct HasPtr: Constant<bool,
|
||||
(sizeof(ptr_test<T>(0)) == 1)
|
||||
> {};
|
||||
|
||||
|
@ -327,7 +327,7 @@ namespace detail {
|
|||
RemoveCv<PointerElement<T>>,
|
||||
RemoveCv<PointerElement<U>>
|
||||
>> struct SameOrLessCvQualifiedBase:
|
||||
IntegralConstant<bool, IsConvertible<T, U>> {};
|
||||
Constant<bool, IsConvertible<T, U>> {};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct SameOrLessCvQualifiedBase<T, U, false>: False {};
|
||||
|
@ -850,7 +850,7 @@ namespace detail {
|
|||
|
||||
template<typename A, bool = IsAlwaysEqualTest<A>::value>
|
||||
struct IsAlwaysEqualBase {
|
||||
using Type = IntegralConstant<bool, IsEmpty<A>>;
|
||||
using Type = Constant<bool, IsEmpty<A>>;
|
||||
};
|
||||
|
||||
template<typename A>
|
||||
|
@ -880,7 +880,7 @@ namespace detail {
|
|||
-> False;
|
||||
|
||||
template<typename A, typename S, typename CVP>
|
||||
struct AllocateHintTest: IntegralConstant<bool,
|
||||
struct AllocateHintTest: Constant<bool,
|
||||
IsSame<decltype(allocate_hint_test(declval<A>(),
|
||||
declval<S>(),
|
||||
declval<CVP>())), True
|
||||
|
@ -933,7 +933,7 @@ namespace detail {
|
|||
-> False;
|
||||
|
||||
template<typename A, typename T, typename ...Args>
|
||||
struct ConstructTest: IntegralConstant<bool,
|
||||
struct ConstructTest: Constant<bool,
|
||||
IsSame< decltype(construct_test(declval<A>(),
|
||||
declval<T>(),
|
||||
declval<Args>()...)), True
|
||||
|
@ -967,7 +967,7 @@ namespace detail {
|
|||
auto destroy_test(const A &, P &&) -> False;
|
||||
|
||||
template<typename A, typename P>
|
||||
struct DestroyTest: IntegralConstant<bool,
|
||||
struct DestroyTest: Constant<bool,
|
||||
IsSame<decltype(destroy_test(declval<A>(), declval<P>())), True>
|
||||
> {};
|
||||
|
||||
|
@ -997,7 +997,7 @@ namespace detail {
|
|||
auto alloc_max_size_test(const A &) -> False;
|
||||
|
||||
template<typename A>
|
||||
struct AllocMaxSizeTest: IntegralConstant<bool,
|
||||
struct AllocMaxSizeTest: Constant<bool,
|
||||
IsSame<decltype(alloc_max_size_test(declval<A &>())), True>
|
||||
> {};
|
||||
|
||||
|
@ -1027,7 +1027,7 @@ namespace detail {
|
|||
auto alloc_copy_test(const A &) -> False;
|
||||
|
||||
template<typename A>
|
||||
struct AllocCopyTest: IntegralConstant<bool,
|
||||
struct AllocCopyTest: Constant<bool,
|
||||
IsSame<decltype(alloc_copy_test(declval<A &>())), True>
|
||||
> {};
|
||||
|
||||
|
@ -1065,7 +1065,7 @@ namespace detail {
|
|||
};
|
||||
|
||||
template<typename T, typename A, bool = HasAllocatorType<T>::value>
|
||||
struct UsesAllocatorBase: IntegralConstant<bool,
|
||||
struct UsesAllocatorBase: Constant<bool,
|
||||
IsConvertible<A, typename T::Allocator>
|
||||
> {};
|
||||
|
||||
|
@ -1090,7 +1090,7 @@ namespace detail {
|
|||
}
|
||||
|
||||
template<typename T, typename A, typename ...Args>
|
||||
struct UsesAllocatorConstructor: IntegralConstant<int,
|
||||
struct UsesAllocatorConstructor: Constant<int,
|
||||
detail::UsesAllocCtor<T, A, Args...>::value
|
||||
> {};
|
||||
|
||||
|
|
|
@ -658,7 +658,7 @@ namespace detail {
|
|||
|
||||
template<typename T, typename R>
|
||||
auto test_stringify(int) ->
|
||||
IntegralConstant<bool, IsSame<decltype(declval<T>().stringify()), String>>;
|
||||
Constant<bool, IsSame<decltype(declval<T>().stringify()), String>>;
|
||||
|
||||
template<typename T, typename R>
|
||||
static True test_stringify(decltype(declval<const T &>().to_string
|
||||
|
|
|
@ -18,7 +18,7 @@ namespace ostd {
|
|||
/* tuple size */
|
||||
|
||||
template<typename ...T> struct TupleSize<Tuple<T...>>:
|
||||
IntegralConstant<Size, sizeof...(T)> {};
|
||||
Constant<Size, sizeof...(T)> {};
|
||||
|
||||
/* tuple element */
|
||||
|
||||
|
@ -38,17 +38,17 @@ namespace detail {
|
|||
}
|
||||
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 0>, const A &): p_value() {
|
||||
TupleLeaf(Constant<int, 0>, const A &): p_value() {
|
||||
static_assert(!IsReference<H>,
|
||||
"attempt to default construct a reference element in a tuple");
|
||||
}
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 1>, const A &a): p_value(allocator_arg, a) {
|
||||
TupleLeaf(Constant<int, 1>, const A &a): p_value(allocator_arg, a) {
|
||||
static_assert(!IsReference<H>,
|
||||
"attempt to default construct a reference element in a tuple");
|
||||
}
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 2>, const A &a): p_value(a) {
|
||||
TupleLeaf(Constant<int, 2>, const A &a): p_value(a) {
|
||||
static_assert(!IsReference<H>,
|
||||
"attempt to default construct a reference element in a tuple");
|
||||
}
|
||||
|
@ -68,7 +68,7 @@ namespace detail {
|
|||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 0>, const A &, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 0>, const A &, T &&t):
|
||||
p_value(forward<T>(t)) {
|
||||
static_assert(!IsLvalueReference<H> ||
|
||||
(IsLvalueReference<H> &&
|
||||
|
@ -79,7 +79,7 @@ namespace detail {
|
|||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 1>, const A &a, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t):
|
||||
p_value(allocator_arg, a, forward<T>(t)) {
|
||||
static_assert(!IsLvalueReference<H> ||
|
||||
(IsLvalueReference<H> &&
|
||||
|
@ -90,7 +90,7 @@ namespace detail {
|
|||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 2>, const A &a, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t):
|
||||
p_value(forward<T>(t), a) {
|
||||
static_assert(!IsLvalueReference<H> ||
|
||||
(IsLvalueReference<H> &&
|
||||
|
@ -126,29 +126,29 @@ namespace detail {
|
|||
constexpr TupleLeaf() {}
|
||||
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 0>, const A &) {}
|
||||
TupleLeaf(Constant<int, 0>, const A &) {}
|
||||
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 1>, const A &a):
|
||||
TupleLeaf(Constant<int, 1>, const A &a):
|
||||
H(allocator_arg, a) {}
|
||||
|
||||
template<typename A>
|
||||
TupleLeaf(IntegralConstant<int, 2>, const A &a): H(a) {}
|
||||
TupleLeaf(Constant<int, 2>, const A &a): H(a) {}
|
||||
|
||||
template<typename T, typename = EnableIf<
|
||||
!IsSame<Decay<T>, TupleLeaf> && IsConstructible<H, T>
|
||||
>> explicit TupleLeaf(T &&t): H(forward<T>(t)) {}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 0>, const A &, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 0>, const A &, T &&t):
|
||||
H(forward<T>(t)) {}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 1>, const A &a, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t):
|
||||
H(allocator_arg, a, forward<T>(t)) {}
|
||||
|
||||
template<typename T, typename A>
|
||||
explicit TupleLeaf(IntegralConstant<int, 2>, const A &a, T &&t):
|
||||
explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t):
|
||||
H(forward<T>(t), a) {}
|
||||
|
||||
TupleLeaf(const TupleLeaf &) = default;
|
||||
|
@ -179,7 +179,7 @@ namespace detail {
|
|||
inline void tuple_swallow(A &&...) {}
|
||||
|
||||
template<bool ...A> struct TupleAll:
|
||||
IntegralConstant<bool, IsSame<TupleAll<A...>, TupleAll<(A, true)...>>> {};
|
||||
Constant<bool, IsSame<TupleAll<A...>, TupleAll<(A, true)...>>> {};
|
||||
|
||||
template<typename T>
|
||||
struct TupleAllDefaultConstructible;
|
||||
|
|
|
@ -49,20 +49,20 @@ namespace detail {
|
|||
/* integral constant */
|
||||
|
||||
template<typename T, T val>
|
||||
struct IntegralConstant {
|
||||
struct Constant {
|
||||
static constexpr T value = val;
|
||||
|
||||
using Value = T;
|
||||
using Type = IntegralConstant<T, val>;
|
||||
using Type = Constant<T, val>;
|
||||
|
||||
constexpr operator Value() const { return value; }
|
||||
constexpr Value operator()() const { return value; }
|
||||
};
|
||||
|
||||
using True = IntegralConstant<bool, true>;
|
||||
using False = IntegralConstant<bool, false>;
|
||||
using True = Constant<bool, true>;
|
||||
using False = Constant<bool, false>;
|
||||
|
||||
template<typename T, T val> constexpr T IntegralConstant<T, val>::value;
|
||||
template<typename T, T val> constexpr T Constant<T, val>::value;
|
||||
|
||||
/* type equality */
|
||||
|
||||
|
@ -609,7 +609,7 @@ namespace detail {
|
|||
template<typename F, typename T, bool = IsVoid<F>
|
||||
|| IsFunction<T> || IsArray<T>
|
||||
> struct IsConvertibleBase {
|
||||
using Type = IntegralConstant<bool, IsVoid<T>>;
|
||||
using Type = Constant<bool, IsVoid<T>>;
|
||||
};
|
||||
|
||||
template<typename F, typename T>
|
||||
|
|
|
@ -50,7 +50,7 @@ template<typename T> AddRvalueReference<T> declval();
|
|||
namespace detail {
|
||||
template<typename T>
|
||||
auto test_swap(int) ->
|
||||
IntegralConstant<bool, IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
|
||||
Constant<bool, IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
|
||||
template<typename>
|
||||
False test_swap(...);
|
||||
|
||||
|
@ -209,7 +209,7 @@ inline constexpr bool operator>=(const Pair<T, U> &x, const Pair<T, U> &y) {
|
|||
}
|
||||
|
||||
template<typename T, typename U>
|
||||
struct TupleSize<Pair<T, U>>: IntegralConstant<Size, 2> {};
|
||||
struct TupleSize<Pair<T, U>>: Constant<Size, 2> {};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct TupleElementBase<0, Pair<T, U>> {
|
||||
|
|
Loading…
Reference in a new issue