482 lines
13 KiB
C++
482 lines
13 KiB
C++
/* Utilities for OctaSTD.
|
|
*
|
|
* This file is part of OctaSTD. See COPYING.md for futher information.
|
|
*/
|
|
|
|
#ifndef OSTD_UTILITY_HH
|
|
#define OSTD_UTILITY_HH
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "ostd/type_traits.hh"
|
|
#include "ostd/internal/tuple.hh"
|
|
|
|
namespace ostd {
|
|
|
|
/* move */
|
|
|
|
template<typename T>
|
|
inline constexpr RemoveReference<T> &&move(T &&v) noexcept {
|
|
return static_cast<RemoveReference<T> &&>(v);
|
|
}
|
|
|
|
/* forward */
|
|
|
|
template<typename T>
|
|
inline constexpr T &&forward(RemoveReference<T> &v) noexcept {
|
|
return static_cast<T &&>(v);
|
|
}
|
|
|
|
template<typename T>
|
|
inline constexpr T &&forward(RemoveReference<T> &&v) noexcept {
|
|
return static_cast<T &&>(v);
|
|
}
|
|
|
|
/* exchange */
|
|
|
|
template<typename T, typename U = T>
|
|
inline T exchange(T &v, U &&nv) {
|
|
T old = move(v);
|
|
v = forward<U>(nv);
|
|
return old;
|
|
}
|
|
|
|
/* declval */
|
|
|
|
template<typename T>
|
|
AddRvalueReference<T> declval() noexcept;
|
|
|
|
/* swap */
|
|
|
|
namespace detail {
|
|
template<typename T>
|
|
auto test_swap(int) ->
|
|
BoolConstant<IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
|
|
template<typename>
|
|
False test_swap(...);
|
|
|
|
template<typename T>
|
|
inline void swap_fb(
|
|
T &a, T &b, EnableIf<decltype(test_swap<T>(0))::value, bool> = true
|
|
) noexcept(noexcept(a.swap(b))) {
|
|
a.swap(b);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void swap_fb(
|
|
T &a, T &b, EnableIf<!decltype(test_swap<T>(0))::value, bool> = true
|
|
) noexcept(IsNothrowMoveConstructible<T> && IsNothrowMoveAssignable<T>) {
|
|
T c(move(a));
|
|
a = move(b);
|
|
b = move(c);
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
inline void swap(T &a, T &b) noexcept(noexcept(detail::swap_fb(a, b))) {
|
|
detail::swap_fb(a, b);
|
|
}
|
|
|
|
template<typename T, Size N>
|
|
inline void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))) {
|
|
for (Size i = 0; i < N; ++i) {
|
|
swap(a[i], b[i]);
|
|
}
|
|
}
|
|
|
|
namespace detail {
|
|
namespace adl_swap {
|
|
using ostd::swap;
|
|
template<typename T>
|
|
inline void swap_adl(T &a, T &b) noexcept(noexcept(swap(a, b))) {
|
|
swap(a, b);
|
|
}
|
|
}
|
|
template<typename T>
|
|
inline void swap_adl(T &a, T &b) noexcept(noexcept(adl_swap::swap_adl(a, b))) {
|
|
adl_swap::swap_adl(a, b);
|
|
}
|
|
}
|
|
|
|
/* pair */
|
|
|
|
struct PiecewiseConstruct {};
|
|
constexpr PiecewiseConstruct piecewise_construct = {};
|
|
|
|
template<typename T, typename U>
|
|
struct Pair {
|
|
T first;
|
|
U second;
|
|
|
|
Pair() = default;
|
|
~Pair() = default;
|
|
|
|
Pair(Pair const &) = default;
|
|
Pair(Pair &&) = default;
|
|
|
|
Pair(T const &x, U const &y): first(x), second(y) {}
|
|
|
|
template<typename TT, typename UU>
|
|
Pair(TT &&x, UU &&y):
|
|
first(forward<TT>(x)), second(forward<UU>(y))
|
|
{}
|
|
|
|
template<typename TT, typename UU>
|
|
Pair(Pair<TT, UU> const &v): first(v.first), second(v.second) {}
|
|
|
|
template<typename TT, typename UU>
|
|
Pair(Pair<TT, UU> &&v):
|
|
first(move(v.first)), second(move(v.second))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2>
|
|
Pair(PiecewiseConstruct pc, Tuple<A1...> fa, Tuple<A2...> sa):
|
|
Pair(
|
|
pc, fa, sa,
|
|
detail::MakeTupleIndices<sizeof...(A1)>(),
|
|
detail::MakeTupleIndices<sizeof...(A2)>()
|
|
)
|
|
{}
|
|
|
|
Pair &operator=(Pair const &v) {
|
|
first = v.first;
|
|
second = v.second;
|
|
return *this;
|
|
}
|
|
|
|
template<typename TT, typename UU>
|
|
Pair &operator=(Pair<TT, UU> const &v) {
|
|
first = v.first;
|
|
second = v.second;
|
|
return *this;
|
|
}
|
|
|
|
Pair &operator=(Pair &&v) noexcept(
|
|
IsNothrowMoveAssignable<T> && IsNothrowMoveAssignable<U>
|
|
) {
|
|
first = move(v.first);
|
|
second = move(v.second);
|
|
return *this;
|
|
}
|
|
|
|
template<typename TT, typename UU>
|
|
Pair &operator=(Pair<TT, UU> &&v) {
|
|
first = forward<TT>(v.first);
|
|
second = forward<UU>(v.second);
|
|
return *this;
|
|
}
|
|
|
|
void swap(Pair &v) noexcept(
|
|
noexcept(detail::swap_adl(first, v.first)) &&
|
|
noexcept(detail::swap_adl(second, v.second))
|
|
) {
|
|
detail::swap_adl(first, v.first);
|
|
detail::swap_adl(second, v.second);
|
|
}
|
|
|
|
private:
|
|
template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
|
|
Pair(
|
|
PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
|
|
detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
|
|
);
|
|
};
|
|
|
|
template<typename T>
|
|
struct ReferenceWrapper;
|
|
|
|
namespace detail {
|
|
template<typename T>
|
|
struct MakePairRetBase {
|
|
using Type = T;
|
|
};
|
|
|
|
template<typename T>
|
|
struct MakePairRetBase<ReferenceWrapper<T>> {
|
|
using Type = T &;
|
|
};
|
|
|
|
template<typename T>
|
|
struct MakePairRet {
|
|
using Type = typename detail::MakePairRetBase<Decay<T>>::Type;
|
|
};
|
|
} /* namespace detail */
|
|
|
|
template<typename T, typename U>
|
|
inline Pair<
|
|
typename detail::MakePairRet<T>::Type, typename detail::MakePairRet<U>::Type
|
|
> make_pair(T &&a, U &&b) {
|
|
return Pair<
|
|
typename detail::MakePairRet<T>::Type,
|
|
typename detail::MakePairRet<U>::Type
|
|
>(forward<T>(a), forward<U>(b));
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator==(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return (x.first == y.first) && (x.second == y.second);
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator!=(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return (x.first != y.first) || (x.second != y.second);
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator<(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return (x.first < y.first)
|
|
? true
|
|
: ((y.first < x.first)
|
|
? false
|
|
: ((x.second < y.second)
|
|
? true
|
|
: false));
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator>(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return (y < x);
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator<=(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return !(y < x);
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
inline constexpr bool operator>=(Pair<T, U> const &x, Pair<T, U> const &y) {
|
|
return !(x < y);
|
|
}
|
|
|
|
template<typename T, typename U>
|
|
constexpr Size TupleSize<Pair<T, U>> = 2;
|
|
|
|
template<typename T, typename U>
|
|
struct TupleElementBase<0, Pair<T, U>> {
|
|
using Type = T;
|
|
};
|
|
|
|
template<typename T, typename U>
|
|
struct TupleElementBase<1, Pair<T, U>> {
|
|
using Type = U;
|
|
};
|
|
|
|
namespace detail {
|
|
template<Size>
|
|
struct GetPair;
|
|
|
|
template<>
|
|
struct GetPair<0> {
|
|
template<typename T, typename U>
|
|
static T &get(Pair<T, U> &p) { return p.first; }
|
|
template<typename T, typename U>
|
|
static T const &get(Pair<T, U> const &p) { return p.first; }
|
|
template<typename T, typename U>
|
|
static T &&get(Pair<T, U> &&p) { return forward<T>(p.first); }
|
|
template<typename T, typename U>
|
|
static T const &&get(Pair<T, U> const &&p) {
|
|
return forward<T const>(p.first);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct GetPair<1> {
|
|
template<typename T, typename U>
|
|
static U &get(Pair<T, U> &p) { return p.second; }
|
|
template<typename T, typename U>
|
|
static U const &get(Pair<T, U> const &p) { return p.second; }
|
|
template<typename T, typename U>
|
|
static U &&get(Pair<T, U> &&p) { return forward<U>(p.second); }
|
|
template<typename T, typename U>
|
|
static T const &&get(Pair<T, U> const &&p) {
|
|
return forward<T const>(p.second);
|
|
}
|
|
};
|
|
}
|
|
|
|
template<Size I, typename T, typename U>
|
|
inline TupleElement<I, Pair<T, U>> &get(Pair<T, U> &p) noexcept {
|
|
return detail::GetPair<I>::get(p);
|
|
}
|
|
|
|
template<Size I, typename T, typename U>
|
|
inline TupleElement<I, Pair<T, U>> const &get(Pair<T, U> const &p) noexcept {
|
|
return detail::GetPair<I>::get(p);
|
|
}
|
|
|
|
template<Size I, typename T, typename U>
|
|
inline TupleElement<I, Pair<T, U>> &&get(Pair<T, U> &&p) noexcept {
|
|
return detail::GetPair<I>::get(move(p));
|
|
}
|
|
|
|
template<Size I, typename T, typename U>
|
|
inline TupleElement<I, Pair<T, U>> const &&get(Pair<T, U> const &&p) noexcept {
|
|
return detail::GetPair<I>::get(move(p));
|
|
}
|
|
|
|
namespace detail {
|
|
template<typename T, typename U,
|
|
bool = IsSame<RemoveCv<T>, RemoveCv<U>>,
|
|
bool = IsEmpty<T>, bool = IsEmpty<U>
|
|
>
|
|
constexpr Size CompressedPairSwitch = detail::Undefined<T>();
|
|
|
|
/* neither empty */
|
|
template<typename T, typename U, bool Same>
|
|
constexpr Size CompressedPairSwitch<T, U, Same, false, false> = 0;
|
|
|
|
/* first empty */
|
|
template<typename T, typename U, bool Same>
|
|
constexpr Size CompressedPairSwitch<T, U, Same, true, false> = 1;
|
|
|
|
/* second empty */
|
|
template<typename T, typename U, bool Same>
|
|
constexpr Size CompressedPairSwitch<T, U, Same, false, true> = 2;
|
|
|
|
/* both empty, not the same */
|
|
template<typename T, typename U>
|
|
constexpr Size CompressedPairSwitch<T, U, false, true, true> = 3;
|
|
|
|
/* both empty and same */
|
|
template<typename T, typename U>
|
|
constexpr Size CompressedPairSwitch<T, U, true, true, true> = 1;
|
|
|
|
template<typename T, typename U, Size = CompressedPairSwitch<T, U>>
|
|
struct CompressedPairBase;
|
|
|
|
template<typename T, typename U>
|
|
struct CompressedPairBase<T, U, 0> {
|
|
T p_first;
|
|
U p_second;
|
|
|
|
template<typename TT, typename UU>
|
|
CompressedPairBase(TT &&a, UU &&b):
|
|
p_first(forward<TT>(a)), p_second(forward<UU>(b))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
|
|
CompressedPairBase(
|
|
PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
|
|
detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
|
|
);
|
|
|
|
T &first() { return p_first; }
|
|
T const &first() const { return p_first; }
|
|
|
|
U &second() { return p_second; }
|
|
U const &second() const { return p_second; }
|
|
|
|
void swap(CompressedPairBase &v) {
|
|
swap_adl(p_first, v.p_first);
|
|
swap_adl(p_second, v.p_second);
|
|
}
|
|
};
|
|
|
|
template<typename T, typename U>
|
|
struct CompressedPairBase<T, U, 1>: T {
|
|
U p_second;
|
|
|
|
template<typename TT, typename UU>
|
|
CompressedPairBase(TT &&a, UU &&b):
|
|
T(forward<TT>(a)), p_second(forward<UU>(b))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
|
|
CompressedPairBase(
|
|
PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
|
|
detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
|
|
);
|
|
|
|
T &first() { return *this; }
|
|
T const &first() const { return *this; }
|
|
|
|
U &second() { return p_second; }
|
|
U const &second() const { return p_second; }
|
|
|
|
void swap(CompressedPairBase &v) {
|
|
swap_adl(p_second, v.p_second);
|
|
}
|
|
};
|
|
|
|
template<typename T, typename U>
|
|
struct CompressedPairBase<T, U, 2>: U {
|
|
T p_first;
|
|
|
|
template<typename TT, typename UU>
|
|
CompressedPairBase(TT &&a, UU &&b):
|
|
U(forward<UU>(b)), p_first(forward<TT>(a))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
|
|
CompressedPairBase(
|
|
PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
|
|
detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
|
|
);
|
|
|
|
T &first() { return p_first; }
|
|
T const &first() const { return p_first; }
|
|
|
|
U &second() { return *this; }
|
|
U const &second() const { return *this; }
|
|
|
|
void swap(CompressedPairBase &v) {
|
|
swap_adl(p_first, v.p_first);
|
|
}
|
|
};
|
|
|
|
template<typename T, typename U>
|
|
struct CompressedPairBase<T, U, 3>: T, U {
|
|
template<typename TT, typename UU>
|
|
CompressedPairBase(TT &&a, UU &&b):
|
|
T(forward<TT>(a)), U(forward<UU>(b))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
|
|
CompressedPairBase(
|
|
PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
|
|
detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
|
|
);
|
|
|
|
T &first() { return *this; }
|
|
T const &first() const { return *this; }
|
|
|
|
U &second() { return *this; }
|
|
U const &second() const { return *this; }
|
|
|
|
void swap(CompressedPairBase &) {}
|
|
};
|
|
|
|
template<typename T, typename U>
|
|
struct CompressedPair: CompressedPairBase<T, U> {
|
|
using Base = CompressedPairBase<T, U>;
|
|
|
|
template<typename TT, typename UU>
|
|
CompressedPair(TT &&a, UU &&b):
|
|
Base(forward<TT>(a), forward<UU>(b))
|
|
{}
|
|
|
|
template<typename ...A1, typename ...A2>
|
|
CompressedPair(PiecewiseConstruct pc, Tuple<A1...> fa, Tuple<A2...> sa):
|
|
Base(
|
|
pc, fa, sa,
|
|
detail::MakeTupleIndices<sizeof...(A1)>(),
|
|
detail::MakeTupleIndices<sizeof...(A2)>()
|
|
)
|
|
{}
|
|
|
|
T &first() { return Base::first(); }
|
|
T const &first() const { return Base::first(); }
|
|
|
|
U &second() { return Base::second(); }
|
|
U const &second() const { return Base::second(); }
|
|
|
|
void swap(CompressedPair &v) {
|
|
Base::swap(v);
|
|
}
|
|
};
|
|
} /* namespace detail */
|
|
|
|
} /* namespace ostd */
|
|
|
|
#endif
|