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

coding style

master
Daniel Kolesa 2015-05-03 23:44:48 +01:00
parent 6a9d3b8ea7
commit 98e7566ad9
6 changed files with 106 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
octa/array.h
View File

@ -13,15 +13,15 @@
namespace octa {
template<typename T, size_t N>
struct Array {
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
typedef T &reference;
typedef const T &const_reference;
typedef T *pointer;
typedef const T *const_pointer;
typedef PointerRange< T> range;
typedef PointerRange<const T> const_range;
typedef size_t SizeType;
typedef ptrdiff_t DiffType;
typedef T ValType;
typedef T &RefType;
typedef const T &ConstRefType;
typedef T *PtrType;
typedef const T *ConstPtrType;
typedef PointerRange< T> RangeType;
typedef PointerRange<const T> ConstRangeType;
T &operator[](size_t i) noexcept { return p_buf[i]; }
const T &operator[](size_t i) const noexcept { return p_buf[i]; }
@ -45,10 +45,10 @@ namespace octa {
swap(p_buf, v.p_buf);
}
range each() noexcept {
RangeType each() noexcept {
return PointerRange<T>(p_buf, p_buf + N);
}
const_range each() const noexcept {
ConstRangeType each() const noexcept {
return PointerRange<const T>(p_buf, p_buf + N);
}

62
octa/functional.h
View File

@ -19,9 +19,9 @@ namespace octa {
bool operator()(const T &x, const T &y) const noexcept( \
noexcept(x op y) \
) { return x op y; } \
typedef T first_argument_type; \
typedef T second_argument_type; \
typedef rettype result_type; \
typedef T FirstArgType; \
typedef T SecondArgType; \
typedef rettype ResultType; \
};
__OCTA_DEFINE_BINARY_OP(Less, <, bool)
@ -45,27 +45,27 @@ namespace octa {
template<typename T> struct LogicalNot {
bool operator()(const T &x) const noexcept(noexcept(!x)) { return !x; }
typedef T argument_type;
typedef bool result_type;
typedef T ArgType;
typedef bool ResultType;
};
template<typename T> struct Negate {
bool operator()(const T &x) const noexcept(noexcept(-x)) { return -x; }
typedef T argument_type;
typedef T result_type;
typedef T ArgType;
typedef T ResultType;
};
template<typename T> struct BinaryNegate {
typedef typename T::first_argument_type first_argument_type;
typedef typename T::second_argument_type second_argument_type;
typedef bool result_type;
typedef typename T::FirstArgType FirstArgType;
typedef typename T::SecondArgType SecondArgType;
typedef bool ResultType;
explicit BinaryNegate(const T &f) noexcept(
IsNothrowCopyConstructible<T>::value
): p_fn(f) {}
bool operator()(const first_argument_type &x,
const second_argument_type &y) noexcept(
bool operator()(const FirstArgType &x,
const SecondArgType &y) noexcept(
noexcept(p_fn(x, y))
) {
return !p_fn(x, y);
@ -75,13 +75,13 @@ namespace octa {
};
template<typename T> struct UnaryNegate {
typedef typename T::argument_type argument_type;
typedef bool result_type;
typedef typename T::ArgType ArgType;
typedef bool ResultType;
explicit UnaryNegate(const T &f) noexcept(
IsNothrowCopyConstructible<T>::value
): p_fn(f) {}
bool operator()(const argument_type &x) noexcept(noexcept(p_fn(x))) {
bool operator()(const ArgType &x) noexcept(noexcept(p_fn(x))) {
return !p_fn(x);
}
private:
@ -144,25 +144,25 @@ namespace octa {
template<typename, typename> struct __OctaMemTypes;
template<typename T, typename R, typename ...A>
struct __OctaMemTypes<T, R(A...)> {
typedef R result_type;
typedef T argument_type;
typedef R ResultType;
typedef T ArgType;
};
template<typename T, typename R, typename A>
struct __OctaMemTypes<T, R(A)> {
typedef R result_type;
typedef T first_argument_type;
typedef A second_argument_type;
typedef R ResultType;
typedef T FirstArgType;
typedef A SecondArgType;
};
template<typename T, typename R, typename ...A>
struct __OctaMemTypes<T, R(A...) const> {
typedef R result_type;
typedef const T argument_type;
typedef R ResultType;
typedef const T ArgType;
};
template<typename T, typename R, typename A>
struct __OctaMemTypes<T, R(A) const> {
typedef R result_type;
typedef const T first_argument_type;
typedef A second_argument_type;
typedef R ResultType;
typedef const T FirstArgType;
typedef A SecondArgType;
};
template<typename R, typename T>
@ -333,20 +333,20 @@ namespace octa {
template<typename R, typename...>
struct __OctaFunction {
typedef R result_type;
typedef R ResultType;
};
template<typename R, typename T>
struct __OctaFunction<R, T> {
typedef R result_type;
typedef T argument_type;
typedef R ResultType;
typedef T ArgType;
};
template<typename R, typename T, typename U>
struct __OctaFunction<R, T, U> {
typedef R result_type;
typedef T first_argument_type;
typedef U second_argument_type;
typedef R ResultType;
typedef T FirstArgType;
typedef U SecondArgType;
};
template<typename, typename>

14
octa/initializer_list.h
View File

@ -19,13 +19,13 @@ namespace std {
initializer_list(const T *v, size_t n) noexcept: p_buf(v), p_len(n) {}
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
typedef T &reference;
typedef const T &const_reference;
typedef T *pointer;
typedef const T *const_pointer;
typedef size_t SizeType;
typedef ptrdiff_t DiffType;
typedef T ValType;
typedef T &RefType;
typedef const T &ConstRefType;
typedef T *PtrType;
typedef const T *ConstPtrType;
initializer_list() noexcept: p_buf(nullptr), p_len(0) {}

68
octa/memory.h
View File

@ -47,7 +47,7 @@ namespace octa {
};
template<typename T>
struct __OctaHasDifferenceType {
struct __OctaHasDiffType {
template<typename U>
static int __octa_test(...);
template<typename U>
@ -56,12 +56,12 @@ namespace octa {
static constexpr bool value = (sizeof(__octa_test<T>(0)) == 1);
};
template<typename T, bool = __OctaHasDifferenceType<T>::value>
struct __OctaPtrTraitsDifferenceType {
template<typename T, bool = __OctaHasDiffType<T>::value>
struct __OctaPtrTraitsDiffType {
typedef ptrdiff_t type;
};
template<typename T> struct __OctaPtrTraitsDifferenceType<T, true> {
template<typename T> struct __OctaPtrTraitsDiffType<T, true> {
typedef typename T::difference_type type;
};
@ -105,7 +105,7 @@ namespace octa {
};
template<typename T>
using PointerType = typename __OctaPtrTraitsPointer<T>::type;
using PtrType = typename __OctaPtrTraitsPointer<T>::type;
template<typename T>
struct __OctaPtrTraitsElement {
@ -122,7 +122,7 @@ namespace octa {
template<typename T>
struct __OctaPtrTraitsDifference {
typedef typename __OctaPtrTraitsDifferenceType<T>::type type;
typedef typename __OctaPtrTraitsDiffType<T>::type type;
};
@ -242,7 +242,7 @@ namespace octa {
template<typename T>
static int __octa_ptr_test(...);
template<typename T>
static char __octa_ptr_test(typename T::PointerType * = 0);
static char __octa_ptr_test(typename T::PtrType * = 0);
template<typename T> struct __OctaHasPtr: IntegralConstant<bool,
(sizeof(__octa_ptr_test<T>(0)) == 1)
@ -250,7 +250,7 @@ namespace octa {
template<typename T, typename D, bool = __OctaHasPtr<D>::value>
struct __OctaPtrTypeBase {
typedef typename D::PointerType type;
typedef typename D::PtrType type;
};
template<typename T, typename D> struct __OctaPtrTypeBase<T, D, false> {
@ -265,7 +265,7 @@ namespace octa {
struct Box {
typedef T ElementType;
typedef D DeleterType;
typedef typename __OctaPtrType<T, D>::type PointerType;
typedef typename __OctaPtrType<T, D>::type PtrType;
private:
struct __OctaNat { int x; };
@ -283,16 +283,16 @@ namespace octa {
"Box constructed with null fptr deleter");
}
explicit Box(PointerType p) noexcept: p_stor(p, D()) {
explicit Box(PtrType p) noexcept: p_stor(p, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
Box(PointerType p, Conditional<IsReference<D>::value,
Box(PtrType p, Conditional<IsReference<D>::value,
D, AddLvalueReference<const D>
> d) noexcept: p_stor(p, d) {}
Box(PointerType p, RemoveReference<D> &&d) noexcept: p_stor(p, move(d)) {
Box(PtrType p, RemoveReference<D> &&d) noexcept: p_stor(p, move(d)) {
static_assert(!IsReference<D>::value,
"rvalue deleter cannot be a ref");
}
@ -301,7 +301,7 @@ namespace octa {
template<typename TT, typename DD>
Box(Box<TT, DD> &&u, EnableIf<!IsArray<TT>::value
&& IsConvertible<typename Box<TT, DD>::PointerType, PointerType>::value
&& IsConvertible<typename Box<TT, DD>::PtrType, PtrType>::value
&& IsConvertible<DD, D>::value
&& (!IsReference<D>::value || IsSame<D, DD>::value)
> = __OctaNat()) noexcept: p_stor(u.release(),
@ -315,7 +315,7 @@ namespace octa {
template<typename TT, typename DD>
EnableIf<!IsArray<TT>::value
&& IsConvertible<typename Box<TT, DD>::PointerType, PointerType>::value
&& IsConvertible<typename Box<TT, DD>::PtrType, PtrType>::value
&& IsAssignable<D &, DD &&>::value,
Box &
> operator=(Box<TT, DD> &&u) noexcept {
@ -332,25 +332,25 @@ namespace octa {
~Box() { reset(); }
AddLvalueReference<T> operator*() const { return *p_stor.i_ptr; }
PointerType operator->() const noexcept { return p_stor.i_ptr; }
PtrType operator->() const noexcept { return p_stor.i_ptr; }
explicit operator bool() const noexcept {
return p_stor.i_ptr != nullptr;
}
PointerType get() const noexcept { return p_stor.i_ptr; }
PtrType get() const noexcept { return p_stor.i_ptr; }
D_ref get_deleter() noexcept { return p_stor.get_deleter(); }
D_cref get_deleter() const noexcept { return p_stor.get_deleter(); }
PointerType release() noexcept {
PointerType p = p_stor.i_ptr;
PtrType release() noexcept {
PtrType p = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
return p;
}
void reset(PointerType p = nullptr) noexcept {
PointerType tmp = p_stor.i_ptr;
void reset(PtrType p = nullptr) noexcept {
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = p;
if (tmp) p_stor.get_deleter()(tmp);
}
@ -382,7 +382,7 @@ namespace octa {
struct Box<T[], D> {
typedef T ElementType;
typedef D DeleterType;
typedef typename __OctaPtrType<T, D>::type PointerType;
typedef typename __OctaPtrType<T, D>::type PtrType;
private:
struct __OctaNat { int x; };
@ -401,7 +401,7 @@ namespace octa {
}
template<typename U> explicit Box(U p, EnableIf<
__OctaSameOrLessCvQualified<U, PointerType>::value, __OctaNat
__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
@ -409,7 +409,7 @@ namespace octa {
template<typename U> Box(U p, Conditional<IsReference<D>::value,
D, AddLvalueReference<const D>
> d, EnableIf<__OctaSameOrLessCvQualified<U, PointerType>::value, __OctaNat
> d, EnableIf<__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, d) {}
Box(nullptr_t, Conditional<IsReference<D>::value,
@ -417,7 +417,7 @@ namespace octa {
> d) noexcept: p_stor(nullptr, d) {}
template<typename U> Box(U p, RemoveReference<D> &&d, EnableIf<
__OctaSameOrLessCvQualified<U, PointerType>::value, __OctaNat
__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, move(d)) {
static_assert(!IsReference<D>::value,
"rvalue deleter cannot be a ref");
@ -432,8 +432,8 @@ namespace octa {
template<typename TT, typename DD>
Box(Box<TT, DD> &&u, EnableIf<IsArray<TT>::value
&& __OctaSameOrLessCvQualified<typename Box<TT, DD>::PointerType,
PointerType>::value
&& __OctaSameOrLessCvQualified<typename Box<TT, DD>::PtrType,
PtrType>::value
&& IsConvertible<DD, D>::value
&& (!IsReference<D>::value || IsSame<D, DD>::value)> = __OctaNat()
) noexcept: p_stor(u.release(), forward<DD>(u.get_deleter())) {}
@ -446,8 +446,8 @@ namespace octa {
template<typename TT, typename DD>
EnableIf<IsArray<TT>::value
&& __OctaSameOrLessCvQualified<typename Box<TT, DD>::PointerType,
PointerType>::value
&& __OctaSameOrLessCvQualified<typename Box<TT, DD>::PtrType,
PtrType>::value
&& IsAssignable<D &, DD &&>::value,
Box &
> operator=(Box<TT, DD> &&u) noexcept {
@ -471,27 +471,27 @@ namespace octa {
return p_stor.i_ptr != nullptr;
}
PointerType get() const noexcept { return p_stor.i_ptr; }
PtrType get() const noexcept { return p_stor.i_ptr; }
D_ref get_deleter() noexcept { return p_stor.get_deleter(); }
D_cref get_deleter() const noexcept { return p_stor.get_deleter(); }
PointerType release() noexcept {
PointerType p = p_stor.i_ptr;
PtrType release() noexcept {
PtrType p = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
return p;
}
template<typename U> EnableIf<
__OctaSameOrLessCvQualified<U, PointerType>::value, void
__OctaSameOrLessCvQualified<U, PtrType>::value, void
> reset(U p) noexcept {
PointerType tmp = p_stor.i_ptr;
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = p;
if (tmp) p_stor.get_deleter()(tmp);
}
void reset(nullptr_t) noexcept {
PointerType tmp = p_stor.i_ptr;
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
if (tmp) p_stor.get_deleter()(tmp);
}

24
octa/range.h
View File

@ -19,10 +19,10 @@ namespace octa {
struct BidirectionalRangeTag {};
struct RandomAccessRangeTag {};
template<typename T> using RangeCategory = typename T::range_category;
template<typename T> using RangeSize = typename T::size_type;
template<typename T> using RangeValue = typename T::value_type;
template<typename T> using RangeReference = typename T::reference;
template<typename T> using RangeCategory = typename T::Category;
template<typename T> using RangeSize = typename T::SizeType;
template<typename T> using RangeValue = typename T::ValType;
template<typename T> using RangeReference = typename T::RefType;
template<typename T>
struct __OctaRangeIterator {
@ -47,10 +47,10 @@ namespace octa {
template<typename B, typename C, typename V, typename R = V &,
typename S = size_t
> struct InputRange {
typedef C range_category;
typedef S size_type;
typedef V value_type;
typedef R reference;
typedef C Category;
typedef S SizeType;
typedef V ValType;
typedef R RefType;
__OctaRangeIterator<B> begin() noexcept(
IsNothrowCopyConstructible<B>::value
@ -66,10 +66,10 @@ namespace octa {
template<typename V, typename R = V &, typename S = size_t>
struct OutputRange {
typedef OutputRangeTag range_category;
typedef S size_type;
typedef V value_type;
typedef R reference;
typedef OutputRangeTag Category;
typedef S SizeType;
typedef V ValType;
typedef R RefType;
};
template<typename T>

22
octa/vector.h
View File

@ -37,15 +37,15 @@ namespace octa {
public:
enum { MIN_SIZE = 8 };
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
typedef T &reference;
typedef const T &const_reference;
typedef T *pointer;
typedef const T *const_pointer;
typedef PointerRange< T> range;
typedef PointerRange<const T> const_range;
typedef size_t SizeType;
typedef ptrdiff_t DiffType;
typedef T ValType;
typedef T &RefType;
typedef const T &ConstRefType;
typedef T *PtrType;
typedef const T *ConstPtrType;
typedef PointerRange< T> RangeType;
typedef PointerRange<const T> ConstRangeType;
Vector() noexcept: p_buf(nullptr), p_len(0), p_cap(0) {}
@ -319,10 +319,10 @@ namespace octa {
return insert_range(idx, il.range());
}
range each() noexcept {
RangeType each() noexcept {
return PointerRange<T>(p_buf, p_buf + p_len);
}
const_range each() const noexcept {
ConstRangeType each() const noexcept {
return PointerRange<const T>(p_buf, p_buf + p_len);
}