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

convert some stuff to variable templates

master
Daniel Kolesa 2016-01-16 18:45:55 +00:00
parent 460cded195
commit bc0c3f7577
2 changed files with 46 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
ostd/internal/tuple.hh
View File

@ -181,99 +181,93 @@ namespace detail {
namespace detail { namespace detail {
template<typename, typename> template<typename, typename>
struct TupleConvertibleBase: False {}; constexpr bool TupleConvertibleBase = false;
template<typename T, typename ...TT, typename U, typename ...UU> template<typename T, typename ...TT, typename U, typename ...UU>
struct TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>: constexpr bool TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
Constant<bool, IsConvertible<T, U> && = IsConvertible<T, U> && TupleConvertibleBase<TupleTypes<TT...>,
TupleConvertibleBase<TupleTypes<TT...>, TupleTypes<UU...>>;
TupleTypes<UU...>>::value> {};
template<> template<>
struct TupleConvertibleBase<TupleTypes<>, TupleTypes<>>: True {}; constexpr bool TupleConvertibleBase<TupleTypes<>, TupleTypes<>> = true;
template<bool, typename, typename> template<bool, typename, typename>
struct TupleConvertibleApply: False {}; constexpr bool TupleConvertibleApply = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleConvertibleApply<true, T, U>: TupleConvertibleBase< constexpr bool TupleConvertibleApply<true, T, U>
MakeTupleTypes<T>, MakeTupleTypes<U> = TupleConvertibleBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
> {};
template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value, template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
bool = IsTupleLike<U>::value> bool = IsTupleLike<U>::value>
struct TupleConvertible: False {}; constexpr bool TupleConvertible = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleConvertible<T, U, true, true>: TupleConvertibleApply< constexpr bool TupleConvertible<T, U, true, true> = TupleConvertibleApply<
TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
> {}; >;
} }
/* tuple constructible */ /* tuple constructible */
namespace detail { namespace detail {
template<typename, typename> template<typename, typename>
struct TupleConstructibleBase: False {}; constexpr bool TupleConstructibleBase = false;
template<typename T, typename ...TT, typename U, typename ...UU> template<typename T, typename ...TT, typename U, typename ...UU>
struct TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>: constexpr bool TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
Constant<bool, IsConstructible<U, T> && = IsConstructible<U, T> && TupleConstructibleBase<TupleTypes<TT...>,
TupleConstructibleBase<TupleTypes<TT...>, TupleTypes<UU...>>;
TupleTypes<UU...>>::value> {};
template<> template<>
struct TupleConstructibleBase<TupleTypes<>, TupleTypes<>>: True {}; constexpr bool TupleConstructibleBase<TupleTypes<>, TupleTypes<>> = true;
template<bool, typename, typename> template<bool, typename, typename>
struct TupleConstructibleApply: False {}; constexpr bool TupleConstructibleApply = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleConstructibleApply<true, T, U>: TupleConstructibleBase< constexpr bool TupleConstructibleApply<true, T, U>
MakeTupleTypes<T>, MakeTupleTypes<U> = TupleConstructibleBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
> {};
template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value, template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
bool = IsTupleLike<U>::value> bool = IsTupleLike<U>::value>
struct TupleConstructible: False {}; constexpr bool TupleConstructible = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleConstructible<T, U, true, true>: TupleConstructibleApply< constexpr bool TupleConstructible<T, U, true, true> = TupleConstructibleApply<
TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
> {}; >;
} }
/* tuple assignable */ /* tuple assignable */
namespace detail { namespace detail {
template<typename, typename> template<typename, typename>
struct TupleAssignableBase: False {}; constexpr bool TupleAssignableBase = false;
template<typename T, typename ...TT, typename U, typename ...UU> template<typename T, typename ...TT, typename U, typename ...UU>
struct TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>: constexpr bool TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
Constant<bool, IsAssignable<U &, T> && = IsAssignable<U &, T> && TupleAssignableBase<TupleTypes<TT...>,
TupleAssignableBase<TupleTypes<TT...>, TupleTypes<UU...>>;
TupleTypes<UU...>>::value> {};
template<> template<>
struct TupleAssignableBase<TupleTypes<>, TupleTypes<>>: True {}; constexpr bool TupleAssignableBase<TupleTypes<>, TupleTypes<>> = true;
template<bool, typename, typename> template<bool, typename, typename>
struct TupleAssignableApply: False {}; constexpr bool TupleAssignableApply = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleAssignableApply<true, T, U>: TupleAssignableBase< constexpr bool TupleAssignableApply<true, T, U>
MakeTupleTypes<T>, MakeTupleTypes<U> = TupleAssignableBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
> {};
template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value, template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
bool = IsTupleLike<U>::value> bool = IsTupleLike<U>::value>
struct TupleAssignable: False {}; constexpr bool TupleAssignable = false;
template<typename T, typename U> template<typename T, typename U>
struct TupleAssignable<T, U, true, true>: TupleAssignableApply< constexpr bool TupleAssignable<T, U, true, true> = TupleAssignableApply<
TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
> {}; >;
} }
} /* namespace ostd */ } /* namespace ostd */

27
ostd/tuple.hh
View File

@ -218,13 +218,13 @@ namespace detail {
{} {}
template<typename T, typename = EnableIf< template<typename T, typename = EnableIf<
TupleConstructible<T, Tuple<A...>>::value TupleConstructible<T, Tuple<A...>>
>> TupleBase(T &&t): TupleLeaf<I, A>(forward< >> TupleBase(T &&t): TupleLeaf<I, A>(forward<
TupleElement<I, MakeTupleTypes<T>> TupleElement<I, MakeTupleTypes<T>>
>(get<I>(t)))... {} >(get<I>(t)))... {}
template<typename Alloc, typename T, typename = EnableIf< template<typename Alloc, typename T, typename = EnableIf<
TupleConvertible<T, Tuple<A...>>::value TupleConvertible<T, Tuple<A...>>
>> TupleBase(AllocatorArg, const Alloc &a, T &&t): >> TupleBase(AllocatorArg, const Alloc &a, T &&t):
TupleLeaf<I, A>(UsesAllocatorConstructor< TupleLeaf<I, A>(UsesAllocatorConstructor<
A, Alloc, TupleElement<I, MakeTupleTypes<T>> A, Alloc, TupleElement<I, MakeTupleTypes<T>>
@ -232,7 +232,7 @@ namespace detail {
{} {}
template<typename T> template<typename T>
EnableIf<TupleAssignable<T, Tuple<A...>>::value, TupleBase &> EnableIf<TupleAssignable<T, Tuple<A...>>, TupleBase &>
operator=(T &&t) { operator=(T &&t) {
tuple_swallow(TupleLeaf<I, A>::operator=(forward< tuple_swallow(TupleLeaf<I, A>::operator=(forward<
TupleElement<I, MakeTupleTypes<T>> TupleElement<I, MakeTupleTypes<T>>
@ -302,7 +302,7 @@ public:
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
: sizeof...(A) : sizeof...(A)
> >
>::value && > &&
detail::TupleAllDefaultConstructible< detail::TupleAllDefaultConstructible<
detail::MakeTupleTypes<Tuple, sizeof...(A), detail::MakeTupleTypes<Tuple, sizeof...(A),
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@ -325,14 +325,14 @@ public:
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
: sizeof...(A) : sizeof...(A)
> >
>::value && > &&
!detail::TupleConvertible< !detail::TupleConvertible<
Tuple<T...>, Tuple<T...>,
detail::MakeTupleTypes<Tuple, detail::MakeTupleTypes<Tuple,
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
: sizeof...(A) : sizeof...(A)
> >
>::value && > &&
detail::TupleAllDefaultConstructible< detail::TupleAllDefaultConstructible<
detail::MakeTupleTypes<Tuple, sizeof...(A), detail::MakeTupleTypes<Tuple, sizeof...(A),
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@ -355,7 +355,7 @@ public:
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
: sizeof...(A) : sizeof...(A)
> >
>::value && > &&
detail::TupleAllDefaultConstructible< detail::TupleAllDefaultConstructible<
detail::MakeTupleTypes<Tuple, sizeof...(A), detail::MakeTupleTypes<Tuple, sizeof...(A),
(sizeof...(T) < sizeof...(A)) ? sizeof...(T) (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@ -370,22 +370,21 @@ public:
forward<T>(t)...) {} forward<T>(t)...) {}
template<typename T, EnableIf< template<typename T, EnableIf<
detail::TupleConvertible<T, Tuple>::value, bool detail::TupleConvertible<T, Tuple>, bool
> = true> Tuple(T &&t): p_base(forward<T>(t)) {} > = true> Tuple(T &&t): p_base(forward<T>(t)) {}
template<typename T, EnableIf< template<typename T, EnableIf<
detail::TupleConstructible<T, Tuple>::value && detail::TupleConstructible<T, Tuple> &&
!detail::TupleConvertible<T, Tuple>::value, bool !detail::TupleConvertible<T, Tuple>, bool
> = true> Tuple(T &&t): p_base(forward<T>(t)) {} > = true> Tuple(T &&t): p_base(forward<T>(t)) {}
template<typename Alloc, typename T, typename = EnableIf< template<typename Alloc, typename T, typename = EnableIf<
detail::TupleConvertible<T, Tuple>::value detail::TupleConvertible<T, Tuple>
>> Tuple(AllocatorArg, const Alloc &a, T &&t): >> Tuple(AllocatorArg, const Alloc &a, T &&t):
p_base(allocator_arg, a, forward<T>(t)) {} p_base(allocator_arg, a, forward<T>(t)) {}
template<typename T, typename = EnableIf< template<typename T, typename = EnableIf<detail::TupleAssignable<T, Tuple>>>
detail::TupleAssignable<T, Tuple>::value Tuple &operator=(T &&t) {
>> Tuple &operator=(T &&t) {
p_base.operator=(forward<T>(t)); p_base.operator=(forward<T>(t));
return *this; return *this;
} }