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

more style/consistency stuff

master
Daniel Kolesa 2015-05-03 23:50:09 +01:00
parent 98e7566ad9
commit fb0c7571c1
2 changed files with 189 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
octa/memory.h
View File

@ -33,17 +33,17 @@ namespace octa {
struct __OctaPtrTraitsElementType; struct __OctaPtrTraitsElementType;
template<typename T> struct __OctaPtrTraitsElementType<T, true> { template<typename T> struct __OctaPtrTraitsElementType<T, true> {
typedef typename T::ElementType type; typedef typename T::ElementType Type;
}; };
template<template<typename, typename...> class T, typename U, typename ...A> template<template<typename, typename...> class T, typename U, typename ...A>
struct __OctaPtrTraitsElementType<T<U, A...>, true> { struct __OctaPtrTraitsElementType<T<U, A...>, true> {
typedef typename T<U, A...>::ElementType type; typedef typename T<U, A...>::ElementType Type;
}; };
template<template<typename, typename...> class T, typename U, typename ...A> template<template<typename, typename...> class T, typename U, typename ...A>
struct __OctaPtrTraitsElementType<T<U, A...>, false> { struct __OctaPtrTraitsElementType<T<U, A...>, false> {
typedef U type; typedef U Type;
}; };
template<typename T> template<typename T>
@ -51,18 +51,18 @@ namespace octa {
template<typename U> template<typename U>
static int __octa_test(...); static int __octa_test(...);
template<typename U> template<typename U>
static char __octa_test(typename U::difference_type * = 0); static char __octa_test(typename U::DiffType * = 0);
static constexpr bool value = (sizeof(__octa_test<T>(0)) == 1); static constexpr bool value = (sizeof(__octa_test<T>(0)) == 1);
}; };
template<typename T, bool = __OctaHasDiffType<T>::value> template<typename T, bool = __OctaHasDiffType<T>::value>
struct __OctaPtrTraitsDiffType { struct __OctaPtrTraitsDiffType {
typedef ptrdiff_t type; typedef ptrdiff_t Type;
}; };
template<typename T> struct __OctaPtrTraitsDiffType<T, true> { template<typename T> struct __OctaPtrTraitsDiffType<T, true> {
typedef typename T::difference_type type; typedef typename T::DiffType Type;
}; };
template<typename T, typename U> template<typename T, typename U>
@ -77,66 +77,66 @@ namespace octa {
template<typename T, typename U, bool = __OctaHasRebind<T, U>::value> template<typename T, typename U, bool = __OctaHasRebind<T, U>::value>
struct __OctaPtrTraitsRebindType { struct __OctaPtrTraitsRebindType {
typedef typename T::template rebind<U> type; typedef typename T::template rebind<U> Type;
}; };
template<template<typename, typename...> class T, typename U, template<template<typename, typename...> class T, typename U,
typename ...A, typename V typename ...A, typename V
> >
struct __OctaPtrTraitsRebindType<T<U, A...>, V, true> { struct __OctaPtrTraitsRebindType<T<U, A...>, V, true> {
typedef typename T<U, A...>::template rebind<V> type; typedef typename T<U, A...>::template rebind<V> Type;
}; };
template<template<typename, typename...> class T, typename U, template<template<typename, typename...> class T, typename U,
typename ...A, typename V typename ...A, typename V
> >
struct __OctaPtrTraitsRebindType<T<U, A...>, V, false> { struct __OctaPtrTraitsRebindType<T<U, A...>, V, false> {
typedef T<V, A...> type; typedef T<V, A...> Type;
}; };
template<typename T> template<typename T>
struct __OctaPtrTraitsPointer { struct __OctaPtrTraitsPointer {
typedef T type; typedef T Type;
}; };
template<typename T> template<typename T>
struct __OctaPtrTraitsPointer<T *> { struct __OctaPtrTraitsPointer<T *> {
typedef T *type; typedef T *Type;
}; };
template<typename T> template<typename T>
using PtrType = typename __OctaPtrTraitsPointer<T>::type; using PtrType = typename __OctaPtrTraitsPointer<T>::Type;
template<typename T> template<typename T>
struct __OctaPtrTraitsElement { struct __OctaPtrTraitsElement {
typedef typename __OctaPtrTraitsElementType<T>::type type; typedef typename __OctaPtrTraitsElementType<T>::Type Type;
}; };
template<typename T> template<typename T>
struct __OctaPtrTraitsElement<T *> { struct __OctaPtrTraitsElement<T *> {
typedef T type; typedef T Type;
}; };
template<typename T> template<typename T>
using PointerElement = typename __OctaPtrTraitsElement<T>::type; using PointerElement = typename __OctaPtrTraitsElement<T>::Type;
template<typename T> template<typename T>
struct __OctaPtrTraitsDifference { struct __OctaPtrTraitsDifference {
typedef typename __OctaPtrTraitsDiffType<T>::type type; typedef typename __OctaPtrTraitsDiffType<T>::Type Type;
}; };
template<typename T> template<typename T>
struct __OctaPtrTraitsDifference<T *> { struct __OctaPtrTraitsDifference<T *> {
typedef ptrdiff_t difference_type; typedef ptrdiff_t DiffType;
}; };
template<typename T> template<typename T>
using PointerDifference = typename __OctaPtrTraitsDifference<T>::type; using PointerDifference = typename __OctaPtrTraitsDifference<T>::Type;
template<typename T, typename U> template<typename T, typename U>
struct __OctaPtrTraitsRebind { struct __OctaPtrTraitsRebind {
using type = typename __OctaPtrTraitsRebindType<T, U>::type; using type = typename __OctaPtrTraitsRebindType<T, U>::Type;
}; };
template<typename T, typename U> template<typename T, typename U>
@ -145,7 +145,7 @@ namespace octa {
}; };
template<typename T, typename U> template<typename T, typename U>
using PointerRebind = typename __OctaPtrTraitsRebind<T, U>::type; using PointerRebind = typename __OctaPtrTraitsRebind<T, U>::Type;
struct __OctaPtrTraitsNat {}; struct __OctaPtrTraitsNat {};
@ -250,22 +250,22 @@ namespace octa {
template<typename T, typename D, bool = __OctaHasPtr<D>::value> template<typename T, typename D, bool = __OctaHasPtr<D>::value>
struct __OctaPtrTypeBase { struct __OctaPtrTypeBase {
typedef typename D::PtrType type; typedef typename D::PtrType Type;
}; };
template<typename T, typename D> struct __OctaPtrTypeBase<T, D, false> { template<typename T, typename D> struct __OctaPtrTypeBase<T, D, false> {
typedef T *type; typedef T *Type;
}; };
template<typename T, typename D> struct __OctaPtrType { template<typename T, typename D> struct __OctaPtrType {
typedef typename __OctaPtrTypeBase<T, RemoveReference<D>>::type type; typedef typename __OctaPtrTypeBase<T, RemoveReference<D>>::Type Type;
}; };
template<typename T, typename D = DefaultDelete<T>> template<typename T, typename D = DefaultDelete<T>>
struct Box { struct Box {
typedef T ElementType; typedef T ElementType;
typedef D DeleterType; typedef D DeleterType;
typedef typename __OctaPtrType<T, D>::type PtrType; typedef typename __OctaPtrType<T, D>::Type PtrType;
private: private:
struct __OctaNat { int x; }; struct __OctaNat { int x; };
@ -382,7 +382,7 @@ namespace octa {
struct Box<T[], D> { struct Box<T[], D> {
typedef T ElementType; typedef T ElementType;
typedef D DeleterType; typedef D DeleterType;
typedef typename __OctaPtrType<T, D>::type PtrType; typedef typename __OctaPtrType<T, D>::Type PtrType;
private: private:
struct __OctaNat { int x; }; struct __OctaNat { int x; };

328
octa/type_traits.h
View File

@ -25,7 +25,7 @@ namespace octa {
template<typename...> struct __OctaCommonType; template<typename...> struct __OctaCommonType;
/* declval also defined here to avoid including utility.h */ /* declval also defined here to avoid including utility.h */
template<typename T> typename __OctaAddRr<T>::type __octa_declval(); template<typename T> typename __OctaAddRr<T>::Type __octa_declval();
/* integral constant */ /* integral constant */
@ -33,11 +33,11 @@ namespace octa {
struct IntegralConstant { struct IntegralConstant {
static constexpr T value = val; static constexpr T value = val;
typedef T value_type; typedef T ValType;
typedef IntegralConstant<T, val> type; typedef IntegralConstant<T, val> Type;
constexpr operator value_type() const { return value; } constexpr operator ValType() const { return value; }
constexpr value_type operator()() const { return value; } constexpr ValType operator()() const { return value; }
}; };
typedef IntegralConstant<bool, true> True; typedef IntegralConstant<bool, true> True;
@ -51,7 +51,7 @@ namespace octa {
template< > struct __OctaIsVoid<void>: True {}; template< > struct __OctaIsVoid<void>: True {};
template<typename T> template<typename T>
struct IsVoid: __OctaIsVoid<typename __OctaRemoveCv<T>::type> {}; struct IsVoid: __OctaIsVoid<typename __OctaRemoveCv<T>::Type> {};
/* is null pointer */ /* is null pointer */
@ -59,7 +59,7 @@ namespace octa {
template< > struct __OctaIsNullPointer<nullptr_t>: True {}; template< > struct __OctaIsNullPointer<nullptr_t>: True {};
template<typename T> struct IsNullPointer: __OctaIsNullPointer< template<typename T> struct IsNullPointer: __OctaIsNullPointer<
typename __OctaRemoveCv<T>::type typename __OctaRemoveCv<T>::Type
> {}; > {};
/* is integer */ /* is integer */
@ -80,7 +80,7 @@ namespace octa {
template<> struct __OctaIsIntegral<ullong>: True {}; template<> struct __OctaIsIntegral<ullong>: True {};
template<typename T> template<typename T>
struct IsIntegral: __OctaIsIntegral<typename __OctaRemoveCv<T>::type> {}; struct IsIntegral: __OctaIsIntegral<typename __OctaRemoveCv<T>::Type> {};
/* is floating point */ /* is floating point */
@ -91,7 +91,7 @@ namespace octa {
template<> struct __OctaIsFloatingPoint<ldouble>: True {}; template<> struct __OctaIsFloatingPoint<ldouble>: True {};
template<typename T> template<typename T>
struct IsFloatingPoint: __OctaIsFloatingPoint<typename __OctaRemoveCv<T>::type> {}; struct IsFloatingPoint: __OctaIsFloatingPoint<typename __OctaRemoveCv<T>::Type> {};
/* is array */ /* is array */
@ -105,7 +105,7 @@ namespace octa {
template<typename T> struct __OctaIsPointer<T *>: True {}; template<typename T> struct __OctaIsPointer<T *>: True {};
template<typename T> template<typename T>
struct IsPointer: __OctaIsPointer<typename __OctaRemoveCv<T>::type> {}; struct IsPointer: __OctaIsPointer<typename __OctaRemoveCv<T>::Type> {};
/* is lvalue reference */ /* is lvalue reference */
@ -179,7 +179,7 @@ namespace octa {
template<typename T> template<typename T>
struct IsMemberPointer: __OctaIsMemberPointer< struct IsMemberPointer: __OctaIsMemberPointer<
typename __OctaRemoveCv<T>::type typename __OctaRemoveCv<T>::Type
> {}; > {};
/* is pointer to member object */ /* is pointer to member object */
@ -193,7 +193,7 @@ namespace octa {
> {}; > {};
template<typename T> struct IsMemberObjectPointer: template<typename T> struct IsMemberObjectPointer:
__OctaIsMemberObjectPointer<typename __OctaRemoveCv<T>::type> {}; __OctaIsMemberObjectPointer<typename __OctaRemoveCv<T>::Type> {};
/* is pointer to member function */ /* is pointer to member function */
@ -206,7 +206,7 @@ namespace octa {
> {}; > {};
template<typename T> struct IsMemberFunctionPointer: template<typename T> struct IsMemberFunctionPointer:
__OctaIsMemberFunctionPointer<typename __OctaRemoveCv<T>::type> {}; __OctaIsMemberFunctionPointer<typename __OctaRemoveCv<T>::Type> {};
/* is reference */ /* is reference */
@ -270,14 +270,14 @@ namespace octa {
template<typename T> template<typename T>
struct IsStandardLayout: IntegralConstant<bool, struct IsStandardLayout: IntegralConstant<bool,
IsScalar<typename __OctaRemoveAllExtents<T>::type>::value IsScalar<typename __OctaRemoveAllExtents<T>::Type>::value
> {}; > {};
/* is literal type */ /* is literal type */
template<typename T> template<typename T>
struct IsLiteralType: IntegralConstant<bool, struct IsLiteralType: IntegralConstant<bool,
IsReference<typename __OctaRemoveAllExtents<T>::type>::value IsReference<typename __OctaRemoveAllExtents<T>::Type>::value
|| IsStandardLayout<T>::value || IsStandardLayout<T>::value
> {}; > {};
@ -285,7 +285,7 @@ namespace octa {
template<typename T> template<typename T>
struct IsTriviallyCopyable: IntegralConstant<bool, struct IsTriviallyCopyable: IntegralConstant<bool,
IsScalar<typename __OctaRemoveAllExtents<T>::type>::value IsScalar<typename __OctaRemoveAllExtents<T>::Type>::value
> {}; > {};
/* is trivial */ /* is trivial */
@ -304,14 +304,14 @@ namespace octa {
/* is constructible */ /* is constructible */
#define __OCTA_MOVE(v) static_cast<typename __OctaRemoveReference<decltype(v)>::type &&>(v) #define __OCTA_MOVE(v) static_cast<typename __OctaRemoveReference<decltype(v)>::Type &&>(v)
template<typename, typename T> struct __OctaSelect2nd { typedef T type; }; template<typename, typename T> struct __OctaSelect2nd { typedef T Type; };
struct __OctaAny { __OctaAny(...); }; struct __OctaAny { __OctaAny(...); };
template<typename T, typename ...A> typename __OctaSelect2nd< template<typename T, typename ...A> typename __OctaSelect2nd<
decltype(__OCTA_MOVE(T(__octa_declval<A>()...))), True decltype(__OCTA_MOVE(T(__octa_declval<A>()...))), True
>::type __octa_is_ctible_test(T &&, A &&...); >::Type __octa_is_ctible_test(T &&, A &&...);
#undef __OCTA_MOVE #undef __OCTA_MOVE
@ -321,7 +321,7 @@ namespace octa {
struct __OctaCtibleCore: __OctaCommonType< struct __OctaCtibleCore: __OctaCommonType<
decltype(__octa_is_ctible_test(__octa_declval<T>(), decltype(__octa_is_ctible_test(__octa_declval<T>(),
__octa_declval<A>()...)) __octa_declval<A>()...))
>::type {}; >::Type {};
/* function types are not constructible */ /* function types are not constructible */
template<typename R, typename ...A1, typename ...A2> template<typename R, typename ...A1, typename ...A2>
@ -342,7 +342,7 @@ namespace octa {
template<typename T, typename U> template<typename T, typename U>
struct __OctaCtibleCore<true, T, U>: __OctaCommonType< struct __OctaCtibleCore<true, T, U>: __OctaCommonType<
decltype(__OctaCtibleRef<T>::test(__octa_declval<U>())) decltype(__OctaCtibleRef<T>::test(__octa_declval<U>()))
>::type {}; >::Type {};
/* scalars and references are not constructible from multiple args */ /* scalars and references are not constructible from multiple args */
template<typename T, typename U, typename ...A> template<typename T, typename U, typename ...A>
@ -378,7 +378,7 @@ namespace octa {
/* array types are default constructible if their element type is */ /* array types are default constructible if their element type is */
template<typename T, size_t N> template<typename T, size_t N>
struct __OctaCtibleCore<false, T[N]>: __OctaCtible< struct __OctaCtibleCore<false, T[N]>: __OctaCtible<
typename __OctaRemoveAllExtents<T>::type typename __OctaRemoveAllExtents<T>::Type
> {}; > {};
/* otherwise array types are not constructible by this syntax */ /* otherwise array types are not constructible by this syntax */
@ -399,27 +399,27 @@ namespace octa {
/* is copy constructible */ /* is copy constructible */
template<typename T> struct IsCopyConstructible: IsConstructible<T, template<typename T> struct IsCopyConstructible: IsConstructible<T,
typename __OctaAddLr<typename __OctaAddConst<T>::type>::type typename __OctaAddLr<typename __OctaAddConst<T>::Type>::Type
> {}; > {};
/* is move constructible */ /* is move constructible */
template<typename T> struct IsMoveConstructible: IsConstructible<T, template<typename T> struct IsMoveConstructible: IsConstructible<T,
typename __OctaAddRr<T>::type typename __OctaAddRr<T>::Type
> {}; > {};
/* is assignable */ /* is assignable */
template<typename T, typename U> typename __OctaSelect2nd< template<typename T, typename U> typename __OctaSelect2nd<
decltype((__octa_declval<T>() = __octa_declval<U>())), True decltype((__octa_declval<T>() = __octa_declval<U>())), True
>::type __octa_assign_test(T &&, U &&); >::Type __octa_assign_test(T &&, U &&);
template<typename T> False __octa_assign_test(__OctaAny, T &&); template<typename T> False __octa_assign_test(__OctaAny, T &&);
template<typename T, typename U, bool = IsVoid<T>::value || IsVoid<U>::value> template<typename T, typename U, bool = IsVoid<T>::value || IsVoid<U>::value>
struct __OctaIsAssignable: __OctaCommonType< struct __OctaIsAssignable: __OctaCommonType<
decltype(__octa_assign_test(__octa_declval<T>(), __octa_declval<U>())) decltype(__octa_assign_test(__octa_declval<T>(), __octa_declval<U>()))
>::type {}; >::Type {};
template<typename T, typename U> template<typename T, typename U>
struct __OctaIsAssignable<T, U, true>: False {}; struct __OctaIsAssignable<T, U, true>: False {};
@ -430,25 +430,25 @@ namespace octa {
/* is copy assignable */ /* is copy assignable */
template<typename T> struct IsCopyAssignable: IsAssignable< template<typename T> struct IsCopyAssignable: IsAssignable<
typename __OctaAddLr<T>::type, typename __OctaAddLr<T>::Type,
typename __OctaAddLr<typename __OctaAddConst<T>::type>::type typename __OctaAddLr<typename __OctaAddConst<T>::Type>::Type
> {}; > {};
/* is move assignable */ /* is move assignable */
template<typename T> struct IsMoveAssignable: IsAssignable< template<typename T> struct IsMoveAssignable: IsAssignable<
typename __OctaAddLr<T>::type, typename __OctaAddLr<T>::Type,
const typename __OctaAddRr<T>::type const typename __OctaAddRr<T>::Type
> {}; > {};
/* is destructible */ /* is destructible */
template<typename> struct __OctaIsDtibleApply { typedef int type; }; template<typename> struct __OctaIsDtibleApply { typedef int Type; };
template<typename T> struct IsDestructorWellformed { template<typename T> struct IsDestructorWellformed {
template<typename TT> static char test(typename __OctaIsDtibleApply< template<typename TT> static char test(typename __OctaIsDtibleApply<
decltype(__octa_declval<TT &>().~TT()) decltype(__octa_declval<TT &>().~TT())
>::type); >::Type);
template<typename TT> static int test(...); template<typename TT> static int test(...);
@ -459,7 +459,7 @@ namespace octa {
template<typename T> template<typename T>
struct __OctaDtibleImpl<T, false>: IntegralConstant<bool, struct __OctaDtibleImpl<T, false>: IntegralConstant<bool,
IsDestructorWellformed<typename __OctaRemoveAllExtents<T>::type>::value IsDestructorWellformed<typename __OctaRemoveAllExtents<T>::Type>::value
> {}; > {};
template<typename T> template<typename T>
@ -512,14 +512,14 @@ namespace octa {
template<typename T> template<typename T>
struct IsTriviallyCopyConstructible: IsTriviallyConstructible<T, struct IsTriviallyCopyConstructible: IsTriviallyConstructible<T,
typename __OctaAddLr<const T>::type typename __OctaAddLr<const T>::Type
> {}; > {};
/* is trivially move constructible */ /* is trivially move constructible */
template<typename T> template<typename T>
struct IsTriviallyMoveConstructible: IsTriviallyConstructible<T, struct IsTriviallyMoveConstructible: IsTriviallyConstructible<T,
typename __OctaAddRr<T>::type typename __OctaAddRr<T>::Type
> {}; > {};
/* is trivially assignable */ /* is trivially assignable */
@ -551,14 +551,14 @@ namespace octa {
template<typename T> template<typename T>
struct IsTriviallyCopyAssignable: IsTriviallyAssignable<T, struct IsTriviallyCopyAssignable: IsTriviallyAssignable<T,
typename __OctaAddLr<const T>::type typename __OctaAddLr<const T>::Type
> {}; > {};
/* is trivially move assignable */ /* is trivially move assignable */
template<typename T> template<typename T>
struct IsTriviallyMoveAssignable: IsTriviallyAssignable<T, struct IsTriviallyMoveAssignable: IsTriviallyAssignable<T,
typename __OctaAddRr<T>::type typename __OctaAddRr<T>::Type
> {}; > {};
/* is trivially destructible */ /* is trivially destructible */
@ -602,14 +602,14 @@ namespace octa {
template<typename T> template<typename T>
struct IsNothrowCopyConstructible: IsNothrowConstructible<T, struct IsNothrowCopyConstructible: IsNothrowConstructible<T,
typename __OctaAddLr<const T>::type typename __OctaAddLr<const T>::Type
> {}; > {};
/* is nothrow move constructible */ /* is nothrow move constructible */
template<typename T> template<typename T>
struct IsNothrowMoveConstructible: IsNothrowConstructible<T, struct IsNothrowMoveConstructible: IsNothrowConstructible<T,
typename __OctaAddRr<T>::type typename __OctaAddRr<T>::Type
> {}; > {};
/* is nothrow assignable */ /* is nothrow assignable */
@ -641,14 +641,14 @@ namespace octa {
template<typename T> template<typename T>
struct IsNothrowCopyAssignable: IsNothrowAssignable<T, struct IsNothrowCopyAssignable: IsNothrowAssignable<T,
typename __OctaAddLr<const T>::type typename __OctaAddLr<const T>::Type
> {}; > {};
/* is nothrow move assignable */ /* is nothrow move assignable */
template<typename T> template<typename T>
struct IsNothrowMoveAssignable: IsNothrowAssignable<T, struct IsNothrowMoveAssignable: IsNothrowAssignable<T,
typename __OctaAddRr<T>::type typename __OctaAddRr<T>::Type
> {}; > {};
/* is nothrow destructible */ /* is nothrow destructible */
@ -687,7 +687,7 @@ namespace octa {
template<typename F, typename T, bool = IsVoid<F>::value template<typename F, typename T, bool = IsVoid<F>::value
|| IsFunction<T>::value || IsArray<T>::value || IsFunction<T>::value || IsArray<T>::value
> struct __OctaIsConvertible { > struct __OctaIsConvertible {
typedef typename IsVoid<T>::type type; typedef typename IsVoid<T>::Type Type;
}; };
template<typename F, typename T> struct __OctaIsConvertible<F, T, false> { template<typename F, typename T> struct __OctaIsConvertible<F, T, false> {
@ -699,11 +699,11 @@ namespace octa {
template<typename, typename> static False test(...); template<typename, typename> static False test(...);
typedef decltype(test<F, T>(0)) type; typedef decltype(test<F, T>(0)) Type;
}; };
template<typename F, typename T> template<typename F, typename T>
struct IsConvertible: __OctaIsConvertible<F, T>::type {}; struct IsConvertible: __OctaIsConvertible<F, T>::Type {};
/* type equality */ /* type equality */
@ -740,174 +740,174 @@ namespace octa {
/* remove const, volatile, cv */ /* remove const, volatile, cv */
template<typename T> template<typename T>
struct __OctaRemoveConst { typedef T type; }; struct __OctaRemoveConst { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveConst<const T> { typedef T type; }; struct __OctaRemoveConst<const T> { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveVolatile { typedef T type; }; struct __OctaRemoveVolatile { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveVolatile<volatile T> { typedef T type; }; struct __OctaRemoveVolatile<volatile T> { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveCv { struct __OctaRemoveCv {
typedef typename __OctaRemoveVolatile< typedef typename __OctaRemoveVolatile<
typename __OctaRemoveConst<T>::type typename __OctaRemoveConst<T>::Type
>::type type; >::Type Type;
}; };
template<typename T> template<typename T>
using RemoveConst = typename __OctaRemoveConst<T>::type; using RemoveConst = typename __OctaRemoveConst<T>::Type;
template<typename T> template<typename T>
using RemoveVolatile = typename __OctaRemoveVolatile<T>::type; using RemoveVolatile = typename __OctaRemoveVolatile<T>::Type;
template<typename T> template<typename T>
using RemoveCv = typename __OctaRemoveCv<T>::type; using RemoveCv = typename __OctaRemoveCv<T>::Type;
/* add const, volatile, cv */ /* add const, volatile, cv */
template<typename T, bool = IsReference<T>::value template<typename T, bool = IsReference<T>::value
|| IsFunction<T>::value || IsConst<T>::value> || IsFunction<T>::value || IsConst<T>::value>
struct __Octa__OctaAddConst { typedef T type; }; struct __Octa__OctaAddConst { typedef T Type; };
template<typename T> struct __Octa__OctaAddConst<T, false> { template<typename T> struct __Octa__OctaAddConst<T, false> {
typedef const T type; typedef const T Type;
}; };
template<typename T> struct __OctaAddConst { template<typename T> struct __OctaAddConst {
typedef typename __Octa__OctaAddConst<T>::type type; typedef typename __Octa__OctaAddConst<T>::Type Type;
}; };
template<typename T, bool = IsReference<T>::value template<typename T, bool = IsReference<T>::value
|| IsFunction<T>::value || IsVolatile<T>::value> || IsFunction<T>::value || IsVolatile<T>::value>
struct __Octa__OctaAddVolatile { typedef T type; }; struct __Octa__OctaAddVolatile { typedef T Type; };
template<typename T> struct __Octa__OctaAddVolatile<T, false> { template<typename T> struct __Octa__OctaAddVolatile<T, false> {
typedef volatile T type; typedef volatile T Type;
}; };
template<typename T> struct __OctaAddVolatile { template<typename T> struct __OctaAddVolatile {
typedef typename __Octa__OctaAddVolatile<T>::type type; typedef typename __Octa__OctaAddVolatile<T>::Type Type;
}; };
template<typename T> template<typename T>
struct __OctaAddCv { struct __OctaAddCv {
typedef typename __OctaAddConst< typedef typename __OctaAddConst<
typename __OctaAddVolatile<T>::type typename __OctaAddVolatile<T>::Type
>::type type; >::Type Type;
}; };
template<typename T> template<typename T>
using AddConst = typename __OctaAddConst<T>::type; using AddConst = typename __OctaAddConst<T>::Type;
template<typename T> template<typename T>
using AddVolatile = typename __OctaAddVolatile<T>::type; using AddVolatile = typename __OctaAddVolatile<T>::Type;
template<typename T> template<typename T>
using AddCv = typename __OctaAddCv<T>::type; using AddCv = typename __OctaAddCv<T>::Type;
/* remove reference */ /* remove reference */
template<typename T> template<typename T>
struct __OctaRemoveReference { typedef T type; }; struct __OctaRemoveReference { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveReference<T &> { typedef T type; }; struct __OctaRemoveReference<T &> { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveReference<T &&> { typedef T type; }; struct __OctaRemoveReference<T &&> { typedef T Type; };
template<typename T> template<typename T>
using RemoveReference = typename __OctaRemoveReference<T>::type; using RemoveReference = typename __OctaRemoveReference<T>::Type;
/* remove pointer */ /* remove pointer */
template<typename T> template<typename T>
struct __OctaRemovePointer { typedef T type; }; struct __OctaRemovePointer { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemovePointer<T * > { typedef T type; }; struct __OctaRemovePointer<T * > { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemovePointer<T * const > { typedef T type; }; struct __OctaRemovePointer<T * const > { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemovePointer<T * volatile > { typedef T type; }; struct __OctaRemovePointer<T * volatile > { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemovePointer<T * const volatile> { typedef T type; }; struct __OctaRemovePointer<T * const volatile> { typedef T Type; };
template<typename T> template<typename T>
using RemovePointer = typename __OctaRemovePointer<T>::type; using RemovePointer = typename __OctaRemovePointer<T>::Type;
/* add pointer */ /* add pointer */
template<typename T> struct __OctaAddPointer { template<typename T> struct __OctaAddPointer {
typedef typename __OctaRemoveReference<T>::type *type; typedef typename __OctaRemoveReference<T>::Type *Type;
}; };
template<typename T> template<typename T>
using AddPointer = typename __OctaAddPointer<T>::type; using AddPointer = typename __OctaAddPointer<T>::Type;
/* add lvalue reference */ /* add lvalue reference */
template<typename T> struct __OctaAddLr { typedef T &type; }; template<typename T> struct __OctaAddLr { typedef T &Type; };
template<typename T> struct __OctaAddLr<T &> { typedef T &type; }; template<typename T> struct __OctaAddLr<T &> { typedef T &Type; };
template<typename T> struct __OctaAddLr<T &&> { typedef T &type; }; template<typename T> struct __OctaAddLr<T &&> { typedef T &Type; };
template<> struct __OctaAddLr<void> { template<> struct __OctaAddLr<void> {
typedef void type; typedef void Type;
}; };
template<> struct __OctaAddLr<const void> { template<> struct __OctaAddLr<const void> {
typedef const void type; typedef const void Type;
}; };
template<> struct __OctaAddLr<volatile void> { template<> struct __OctaAddLr<volatile void> {
typedef volatile void type; typedef volatile void Type;
}; };
template<> struct __OctaAddLr<const volatile void> { template<> struct __OctaAddLr<const volatile void> {
typedef const volatile void type; typedef const volatile void Type;
}; };
template<typename T> template<typename T>
using AddLvalueReference = typename __OctaAddLr<T>::type; using AddLvalueReference = typename __OctaAddLr<T>::Type;
/* add rvalue reference */ /* add rvalue reference */
template<typename T> struct __OctaAddRr { typedef T &&type; }; template<typename T> struct __OctaAddRr { typedef T &&Type; };
template<typename T> struct __OctaAddRr<T &> { typedef T &&type; }; template<typename T> struct __OctaAddRr<T &> { typedef T &&Type; };
template<typename T> struct __OctaAddRr<T &&> { typedef T &&type; }; template<typename T> struct __OctaAddRr<T &&> { typedef T &&Type; };
template<> struct __OctaAddRr<void> { template<> struct __OctaAddRr<void> {
typedef void type; typedef void Type;
}; };
template<> struct __OctaAddRr<const void> { template<> struct __OctaAddRr<const void> {
typedef const void type; typedef const void Type;
}; };
template<> struct __OctaAddRr<volatile void> { template<> struct __OctaAddRr<volatile void> {
typedef volatile void type; typedef volatile void Type;
}; };
template<> struct __OctaAddRr<const volatile void> { template<> struct __OctaAddRr<const volatile void> {
typedef const volatile void type; typedef const volatile void Type;
}; };
template<typename T> template<typename T>
using AddRvalueReference = typename __OctaAddRr<T>::type; using AddRvalueReference = typename __OctaAddRr<T>::Type;
/* remove extent */ /* remove extent */
template<typename T> template<typename T>
struct __OctaRemoveExtent { typedef T type; }; struct __OctaRemoveExtent { typedef T Type; };
template<typename T> template<typename T>
struct __OctaRemoveExtent<T[ ]> { typedef T type; }; struct __OctaRemoveExtent<T[ ]> { typedef T Type; };
template<typename T, size_t N> template<typename T, size_t N>
struct __OctaRemoveExtent<T[N]> { typedef T type; }; struct __OctaRemoveExtent<T[N]> { typedef T Type; };
template<typename T> template<typename T>
using RemoveExtent = typename __OctaRemoveExtent<T>::type; using RemoveExtent = typename __OctaRemoveExtent<T>::Type;
/* remove all extents */ /* remove all extents */
template<typename T> struct __OctaRemoveAllExtents { typedef T type; }; template<typename T> struct __OctaRemoveAllExtents { typedef T Type; };
template<typename T> struct __OctaRemoveAllExtents<T[]> { template<typename T> struct __OctaRemoveAllExtents<T[]> {
typedef typename __OctaRemoveAllExtents<T>::type type; typedef typename __OctaRemoveAllExtents<T>::Type Type;
}; };
template<typename T, size_t N> struct __OctaRemoveAllExtents<T[N]> { template<typename T, size_t N> struct __OctaRemoveAllExtents<T[N]> {
typedef typename __OctaRemoveAllExtents<T>::type type; typedef typename __OctaRemoveAllExtents<T>::Type Type;
}; };
template<typename T> template<typename T>
using RemoveAllExtents = typename __OctaRemoveAllExtents<T>::type; using RemoveAllExtents = typename __OctaRemoveAllExtents<T>::Type;
/* make (un)signed /* make (un)signed
* *
@ -945,49 +945,49 @@ namespace octa {
template<typename T, typename U, size_t N> template<typename T, typename U, size_t N>
struct __OctaTypeFindFirst<__OctaTl<T, U>, N, true> { struct __OctaTypeFindFirst<__OctaTl<T, U>, N, true> {
typedef T type; typedef T Type;
}; };
template<typename T, typename U, size_t N> template<typename T, typename U, size_t N>
struct __OctaTypeFindFirst<__OctaTl<T, U>, N, false> { struct __OctaTypeFindFirst<__OctaTl<T, U>, N, false> {
typedef typename __OctaTypeFindFirst<U, N>::type type; typedef typename __OctaTypeFindFirst<U, N>::Type Type;
}; };
template<typename T, typename U, template<typename T, typename U,
bool = IsConst<typename __OctaRemoveReference<T>::type>::value, bool = IsConst<typename __OctaRemoveReference<T>::Type>::value,
bool = IsVolatile<typename __OctaRemoveReference<T>::type>::value bool = IsVolatile<typename __OctaRemoveReference<T>::Type>::value
> struct __OctaApplyCv { > struct __OctaApplyCv {
typedef U type; typedef U Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T, U, true, false> { /* const */ struct __OctaApplyCv<T, U, true, false> { /* const */
typedef const U type; typedef const U Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T, U, false, true> { /* volatile */ struct __OctaApplyCv<T, U, false, true> { /* volatile */
typedef volatile U type; typedef volatile U Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T, U, true, true> { /* const volatile */ struct __OctaApplyCv<T, U, true, true> { /* const volatile */
typedef const volatile U type; typedef const volatile U Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T &, U, true, false> { /* const */ struct __OctaApplyCv<T &, U, true, false> { /* const */
typedef const U &type; typedef const U &Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T &, U, false, true> { /* volatile */ struct __OctaApplyCv<T &, U, false, true> { /* volatile */
typedef volatile U &type; typedef volatile U &Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaApplyCv<T &, U, true, true> { /* const volatile */ struct __OctaApplyCv<T &, U, true, true> { /* const volatile */
typedef const volatile U &type; typedef const volatile U &Type;
}; };
template<typename T, bool = IsIntegral<T>::value || IsEnum<T>::value> template<typename T, bool = IsIntegral<T>::value || IsEnum<T>::value>
@ -998,73 +998,73 @@ namespace octa {
template<typename T> template<typename T>
struct __OctaMakeSigned<T, true> { struct __OctaMakeSigned<T, true> {
typedef typename __OctaTypeFindFirst<stypes, sizeof(T)>::type type; typedef typename __OctaTypeFindFirst<stypes, sizeof(T)>::Type Type;
}; };
template<typename T> template<typename T>
struct __OctaMakeUnsigned<T, true> { struct __OctaMakeUnsigned<T, true> {
typedef typename __OctaTypeFindFirst<utypes, sizeof(T)>::type type; typedef typename __OctaTypeFindFirst<utypes, sizeof(T)>::Type Type;
}; };
template<> struct __OctaMakeSigned<bool , true> {}; template<> struct __OctaMakeSigned<bool , true> {};
template<> struct __OctaMakeSigned<schar , true> { typedef schar type; }; template<> struct __OctaMakeSigned<schar , true> { typedef schar Type; };
template<> struct __OctaMakeSigned<uchar , true> { typedef schar type; }; template<> struct __OctaMakeSigned<uchar , true> { typedef schar Type; };
template<> struct __OctaMakeSigned<short , true> { typedef short type; }; template<> struct __OctaMakeSigned<short , true> { typedef short Type; };
template<> struct __OctaMakeSigned<ushort, true> { typedef short type; }; template<> struct __OctaMakeSigned<ushort, true> { typedef short Type; };
template<> struct __OctaMakeSigned<int , true> { typedef int type; }; template<> struct __OctaMakeSigned<int , true> { typedef int Type; };
template<> struct __OctaMakeSigned<uint , true> { typedef int type; }; template<> struct __OctaMakeSigned<uint , true> { typedef int Type; };
template<> struct __OctaMakeSigned<long , true> { typedef long type; }; template<> struct __OctaMakeSigned<long , true> { typedef long Type; };
template<> struct __OctaMakeSigned<ulong , true> { typedef long type; }; template<> struct __OctaMakeSigned<ulong , true> { typedef long Type; };
template<> struct __OctaMakeSigned<llong , true> { typedef llong type; }; template<> struct __OctaMakeSigned<llong , true> { typedef llong Type; };
template<> struct __OctaMakeSigned<ullong, true> { typedef llong type; }; template<> struct __OctaMakeSigned<ullong, true> { typedef llong Type; };
template<> struct __OctaMakeUnsigned<bool , true> {}; template<> struct __OctaMakeUnsigned<bool , true> {};
template<> struct __OctaMakeUnsigned<schar , true> { typedef uchar type; }; template<> struct __OctaMakeUnsigned<schar , true> { typedef uchar Type; };
template<> struct __OctaMakeUnsigned<uchar , true> { typedef uchar type; }; template<> struct __OctaMakeUnsigned<uchar , true> { typedef uchar Type; };
template<> struct __OctaMakeUnsigned<short , true> { typedef ushort type; }; template<> struct __OctaMakeUnsigned<short , true> { typedef ushort Type; };
template<> struct __OctaMakeUnsigned<ushort, true> { typedef ushort type; }; template<> struct __OctaMakeUnsigned<ushort, true> { typedef ushort Type; };
template<> struct __OctaMakeUnsigned<int , true> { typedef uint type; }; template<> struct __OctaMakeUnsigned<int , true> { typedef uint Type; };
template<> struct __OctaMakeUnsigned<uint , true> { typedef uint type; }; template<> struct __OctaMakeUnsigned<uint , true> { typedef uint Type; };
template<> struct __OctaMakeUnsigned<long , true> { typedef ulong type; }; template<> struct __OctaMakeUnsigned<long , true> { typedef ulong Type; };
template<> struct __OctaMakeUnsigned<ulong , true> { typedef ulong type; }; template<> struct __OctaMakeUnsigned<ulong , true> { typedef ulong Type; };
template<> struct __OctaMakeUnsigned<llong , true> { typedef ullong type; }; template<> struct __OctaMakeUnsigned<llong , true> { typedef ullong Type; };
template<> struct __OctaMakeUnsigned<ullong, true> { typedef ullong type; }; template<> struct __OctaMakeUnsigned<ullong, true> { typedef ullong Type; };
template<typename T> struct __OctaMakeSignedBase { template<typename T> struct __OctaMakeSignedBase {
typedef typename __OctaApplyCv<T, typedef typename __OctaApplyCv<T,
typename __OctaMakeSigned< typename __OctaMakeSigned<
typename __OctaRemoveCv<T>::type typename __OctaRemoveCv<T>::Type
>::type >::Type
>::type type; >::Type Type;
}; };
template<typename T> struct __OctaMakeUnsignedBase { template<typename T> struct __OctaMakeUnsignedBase {
typedef typename __OctaApplyCv<T, typedef typename __OctaApplyCv<T,
typename __OctaMakeUnsigned< typename __OctaMakeUnsigned<
typename __OctaRemoveCv<T>::type typename __OctaRemoveCv<T>::Type
>::type >::Type
>::type type; >::Type Type;
}; };
template<typename T> template<typename T>
using MakeSigned = typename __OctaMakeSignedBase<T>::type; using MakeSigned = typename __OctaMakeSignedBase<T>::Type;
template<typename T> template<typename T>
using MakeUnsigned = typename __OctaMakeUnsignedBase<T>::type; using MakeUnsigned = typename __OctaMakeUnsignedBase<T>::Type;
/* conditional */ /* conditional */
template<bool cond, typename T, typename U> template<bool cond, typename T, typename U>
struct __OctaConditional { struct __OctaConditional {
typedef T type; typedef T Type;
}; };
template<typename T, typename U> template<typename T, typename U>
struct __OctaConditional<false, T, U> { struct __OctaConditional<false, T, U> {
typedef U type; typedef U Type;
}; };
template<bool cond, typename T, typename U> template<bool cond, typename T, typename U>
using Conditional = typename __OctaConditional<cond, T, U>::type; using Conditional = typename __OctaConditional<cond, T, U>::Type;
/* result of call at compile time */ /* result of call at compile time */
@ -1108,57 +1108,57 @@ namespace octa {
template<typename T> struct __OctaResultOfBase: __OctaResultOf<T> {}; template<typename T> struct __OctaResultOfBase: __OctaResultOf<T> {};
template<typename T> template<typename T>
using ResultOf = typename __OctaResultOfBase<T>::type; using ResultOf = typename __OctaResultOfBase<T>::Type;
/* enable if */ /* enable if */
template<bool B, typename T = void> struct __OctaEnableIf {}; template<bool B, typename T = void> struct __OctaEnableIf {};
template<typename T> struct __OctaEnableIf<true, T> { typedef T type; }; template<typename T> struct __OctaEnableIf<true, T> { typedef T Type; };
template<bool B, typename T = void> template<bool B, typename T = void>
using EnableIf = typename __OctaEnableIf<B, T>::type; using EnableIf = typename __OctaEnableIf<B, T>::Type;
/* decay */ /* decay */
template<typename T> template<typename T>
struct __OctaDecay { struct __OctaDecay {
private: private:
typedef typename __OctaRemoveReference<T>::type U; typedef typename __OctaRemoveReference<T>::Type U;
public: public:
typedef typename __OctaConditional<IsArray<U>::value, typedef typename __OctaConditional<IsArray<U>::value,
typename __OctaRemoveExtent<U>::type *, typename __OctaRemoveExtent<U>::Type *,
typename __OctaConditional<IsFunction<U>::value, typename __OctaConditional<IsFunction<U>::value,
typename __OctaAddPointer<U>::type, typename __OctaAddPointer<U>::Type,
typename __OctaRemoveCv<U>::type typename __OctaRemoveCv<U>::Type
>::type >::Type
>::type type; >::Type Type;
}; };
template<typename T> template<typename T>
using Decay = typename __OctaDecay<T>::type; using Decay = typename __OctaDecay<T>::Type;
/* common type */ /* common type */
template<typename ...T> struct __OctaCommonType; template<typename ...T> struct __OctaCommonType;
template<typename T> struct __OctaCommonType<T> { template<typename T> struct __OctaCommonType<T> {
typedef __OctaDecay<T> type; typedef __OctaDecay<T> Type;
}; };
template<typename T, typename U> struct __OctaCommonType<T, U> { template<typename T, typename U> struct __OctaCommonType<T, U> {
typedef __OctaDecay<decltype(true ? __octa_declval<T>() typedef __OctaDecay<decltype(true ? __octa_declval<T>()
: __octa_declval<U>())> type; : __octa_declval<U>())> Type;
}; };
template<typename T, typename U, typename ...V> template<typename T, typename U, typename ...V>
struct __OctaCommonType<T, U, V...> { struct __OctaCommonType<T, U, V...> {
typedef typename __OctaCommonType<typename __OctaCommonType<T, U>::type, typedef typename __OctaCommonType<typename __OctaCommonType<T, U>::Type,
V...>::type type; V...>::Type Type;
}; };
template<typename T, typename U, typename ...V> template<typename T, typename U, typename ...V>
using CommonType = typename __OctaCommonType<T, U, V...>::type; using CommonType = typename __OctaCommonType<T, U, V...>::Type;
/* aligned storage */ /* aligned storage */
@ -1176,8 +1176,8 @@ namespace octa {
}; };
template<size_t N, size_t A template<size_t N, size_t A
= alignof(typename __OctaAlignedTest<N>::type) = alignof(typename __OctaAlignedTest<N>::Type)
> using AlignedStorage = typename __OctaAlignedStorage<N, A>::type; > using AlignedStorage = typename __OctaAlignedStorage<N, A>::Type;
/* aligned union */ /* aligned union */
@ -1208,7 +1208,7 @@ namespace octa {
}; };
template<size_t N, typename ...T> template<size_t N, typename ...T>
using AlignedUnion = typename __OctaAlignedUnion<N, T...>::type; using AlignedUnion = typename __OctaAlignedUnion<N, T...>::Type;
/* underlying type */ /* underlying type */
@ -1217,11 +1217,11 @@ namespace octa {
template<typename T> struct __OctaUnderlyingType<T, true> { template<typename T> struct __OctaUnderlyingType<T, true> {
typedef typename __OctaConditional<IsSigned<T>::value, typedef typename __OctaConditional<IsSigned<T>::value,
MakeSigned<T>, MakeUnsigned<T> MakeSigned<T>, MakeUnsigned<T>
>::type type; >::Type Type;
}; };
template<typename T> template<typename T>
using UnderlyingType = typename __OctaUnderlyingType<T>::type; using UnderlyingType = typename __OctaUnderlyingType<T>::Type;
} }
#endif #endif