JDBtracker
/
libostd
forked from OctaForge/libostd
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rename IntegralConstant to Constant

master
Daniel Kolesa 2016-01-16 18:31:44 +00:00
parent 5237c60dfa
commit 9e4d475488
7 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ostd/array.hh
View File

@ -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>> {

8
ostd/internal/tuple.hh
View File

@ -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> {};

20
ostd/memory.hh
View File

@ -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
> {};

2
ostd/string.hh
View File

@ -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

28
ostd/tuple.hh
View File

@ -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;

12
ostd/type_traits.hh
View File

@ -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>

4
ostd/utility.hh
View File

@ -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>> {