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

noexcept formatting

master
Daniel Kolesa 2015-04-29 01:38:16 +01:00
parent ef47ade61f
commit b1192b248c
4 changed files with 198 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
octa/functional.h
View File

@ -16,8 +16,9 @@ namespace octa {
#define __OCTA_DEFINE_BINARY_OP(name, op, rettype) \
template<typename T> struct name { \
bool operator()(const T &x, const T &y) \
const noexcept(noexcept(x op y)) { return x op y; } \
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; \
@ -59,12 +60,14 @@ namespace octa {
typedef typename T::second_argument_type second_argument_type;
typedef bool result_type;
explicit BinaryNegate(const T &f)
noexcept(IsNothrowCopyConstructible<T>::value): p_fn(f) {}
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(noexcept(p_fn(x, y))) {
const second_argument_type &y) noexcept(
noexcept(p_fn(x, y))
) {
return !p_fn(x, y);
}
private:
@ -75,8 +78,9 @@ namespace octa {
typedef typename T::argument_type argument_type;
typedef bool result_type;
explicit UnaryNegate(const T &f)
noexcept(IsNothrowCopyConstructible<T>::value): p_fn(f) {}
explicit UnaryNegate(const T &f) noexcept(
IsNothrowCopyConstructible<T>::value
): p_fn(f) {}
bool operator()(const argument_type &x) noexcept(noexcept(p_fn(x))) {
return !p_fn(x);
}
@ -84,13 +88,15 @@ namespace octa {
T p_fn;
};
template<typename T> UnaryNegate<T> not1(const T &fn)
noexcept(IsNothrowCopyConstructible<UnaryNegate<T>>::value) {
template<typename T> UnaryNegate<T> not1(const T &fn) noexcept(
IsNothrowCopyConstructible<UnaryNegate<T>>::value
) {
return UnaryNegate<T>(fn);
}
template<typename T> BinaryNegate<T> not2(const T &fn)
noexcept(IsNothrowCopyConstructible<BinaryNegate<T>>::value) {
template<typename T> BinaryNegate<T> not2(const T &fn) noexcept(
IsNothrowCopyConstructible<BinaryNegate<T>>::value
) {
return BinaryNegate<T>(fn);
}

200
octa/range.h
View File

@ -55,12 +55,14 @@ namespace octa {
typedef V value_type;
typedef R reference;
__OctaRangeIterator<B> begin()
noexcept(IsNothrowCopyConstructible<B>::value) {
__OctaRangeIterator<B> begin() noexcept(
IsNothrowCopyConstructible<B>::value
) {
return __OctaRangeIterator<B>((const B &)*this);
}
__OctaRangeIterator<B> end()
noexcept(IsNothrowDefaultConstructible<B>::value) {
__OctaRangeIterator<B> end() noexcept(
IsNothrowDefaultConstructible<B>::value
) {
return __OctaRangeIterator<B>();
}
};
@ -87,36 +89,42 @@ namespace octa {
T p_range;
public:
ReverseRange()
noexcept(IsNothrowDefaultConstructible<T>::value): p_range() {}
ReverseRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range() {}
ReverseRange(const T &range)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(range) {}
ReverseRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range) {}
ReverseRange(const ReverseRange &it)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(it.p_range) {}
ReverseRange(const ReverseRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range) {}
ReverseRange(ReverseRange &&it)
noexcept(IsNothrowMoveConstructible<T>::value):
p_range(move(it.p_range)) {}
ReverseRange(ReverseRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)) {}
ReverseRange &operator=(const ReverseRange &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
ReverseRange &operator=(const ReverseRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v.p_range;
return *this;
}
ReverseRange &operator=(ReverseRange &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
ReverseRange &operator=(ReverseRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v.p_range);
return *this;
}
ReverseRange &operator=(const T &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
ReverseRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v;
return *this;
}
ReverseRange &operator=(T &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
ReverseRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v);
return *this;
}
@ -136,12 +144,14 @@ namespace octa {
p_range.pop_first();
}
bool operator==(const ReverseRange &v) const
noexcept(noexcept(p_range == v.p_range)) {
bool operator==(const ReverseRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
return p_range == v.p_range;
}
bool operator!=(const ReverseRange &v) const
noexcept(noexcept(p_range != v.p_range)) {
bool operator!=(const ReverseRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
return p_range != v.p_range;
}
@ -166,17 +176,19 @@ namespace octa {
return p_range[length() - i - 1];
}
ReverseRange<T> slice(r_size start, r_size end)
noexcept(noexcept(ReverseRange<T>(p_range.slice(0, 0)))
&& noexcept(p_range.length())) {
ReverseRange<T> slice(r_size start, r_size end) noexcept(
noexcept(ReverseRange<T>(p_range.slice(0, 0)))
&& noexcept(p_range.length())
) {
r_size len = p_range.length();
return ReverseRange<T>(p_range.slice(len - end, len - start));
}
};
template<typename T>
ReverseRange<T> make_reverse_range(const T &it)
noexcept(noexcept(ReverseRange<T>(it))) {
ReverseRange<T> make_reverse_range(const T &it) noexcept(
noexcept(ReverseRange<T>(it))
) {
return ReverseRange<T>(it);
}
@ -195,36 +207,42 @@ namespace octa {
T p_range;
public:
MoveRange()
noexcept(IsNothrowDefaultConstructible<T>::value): p_range() {}
MoveRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range() {}
MoveRange(const T &range)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(range) {}
MoveRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range) {}
MoveRange(const MoveRange &it)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(it.p_range) {}
MoveRange(const MoveRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range) {}
MoveRange(MoveRange &&it)
noexcept(IsNothrowMoveConstructible<T>::value):
p_range(move(it.p_range)) {}
MoveRange(MoveRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)) {}
MoveRange &operator=(const MoveRange &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
MoveRange &operator=(const MoveRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v.p_range;
return *this;
}
MoveRange &operator=(MoveRange &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
MoveRange &operator=(MoveRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v.p_range);
return *this;
}
MoveRange &operator=(const T &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
MoveRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v;
return *this;
}
MoveRange &operator=(T &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
MoveRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v);
return *this;
}
@ -243,12 +261,14 @@ namespace octa {
p_range.pop_last();
}
bool operator==(const MoveRange &v) const
noexcept(noexcept(p_range == v.p_range)) {
bool operator==(const MoveRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
return p_range == v.p_range;
}
bool operator!=(const MoveRange &v) const
noexcept(noexcept(p_range != v.p_range)) {
bool operator!=(const MoveRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
return p_range != v.p_range;
}
@ -263,8 +283,9 @@ namespace octa {
return move(p_range[i]);
}
MoveRange<T> slice(r_size start, r_size end)
noexcept(noexcept(MoveRange<T>(p_range.slice(start, end)))) {
MoveRange<T> slice(r_size start, r_size end) noexcept(
noexcept(MoveRange<T>(p_range.slice(start, end)))
) {
return MoveRange<T>(p_range.slice(start, end));
}
@ -274,8 +295,9 @@ namespace octa {
};
template<typename T>
MoveRange<T> make_move_range(const T &it)
noexcept(noexcept(MoveRange<T>(it))) {
MoveRange<T> make_move_range(const T &it) noexcept(
noexcept(MoveRange<T>(it))
) {
return MoveRange<T>(it);
}
@ -388,42 +410,45 @@ namespace octa {
r_size p_index;
public:
EnumeratedRange()
noexcept(IsNothrowDefaultConstructible<T>::value): p_range(),
p_index(0) {}
EnumeratedRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range(), p_index(0) {}
EnumeratedRange(const T &range)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(range),
p_index(0) {}
EnumeratedRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range), p_index(0) {}
EnumeratedRange(const EnumeratedRange &it)
noexcept(IsNothrowCopyConstructible<T>::value): p_range(it.p_range),
p_index(it.p_index) {}
EnumeratedRange(const EnumeratedRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range), p_index(it.p_index) {}
EnumeratedRange(EnumeratedRange &&it)
noexcept(IsNothrowMoveConstructible<T>::value):
p_range(move(it.p_range)), p_index(it.p_index) {}
EnumeratedRange(EnumeratedRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)), p_index(it.p_index) {}
EnumeratedRange &operator=(const EnumeratedRange &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
EnumeratedRange &operator=(const EnumeratedRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v.p_range;
p_index = v.p_index;
return *this;
}
EnumeratedRange &operator=(EnumeratedRange &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
EnumeratedRange &operator=(EnumeratedRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v.p_range);
p_index = v.p_index;
return *this;
}
EnumeratedRange &operator=(const T &v)
noexcept(IsNothrowCopyAssignable<T>::value) {
EnumeratedRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
p_range = v;
p_index = 0;
return *this;
}
EnumeratedRange &operator=(T &&v)
noexcept(IsNothrowMoveAssignable<T>::value) {
EnumeratedRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
p_range = move(v);
p_index = 0;
return *this;
@ -437,28 +462,33 @@ namespace octa {
++p_index; p_range.pop_first();
}
EnumeratedValue<r_ref, r_size> first()
noexcept(noexcept(p_range.first())) {
EnumeratedValue<r_ref, r_size> first() noexcept(
noexcept(p_range.first())
) {
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
}
EnumeratedValue<r_ref, r_size> first() const
noexcept(noexcept(p_range.first())) {
EnumeratedValue<r_ref, r_size> first() const noexcept(
noexcept(p_range.first())
) {
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
}
bool operator==(const EnumeratedRange &v) const
noexcept(noexcept(p_range == v.p_range)) {
bool operator==(const EnumeratedRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
return p_range == v.p_range;
}
bool operator!=(const EnumeratedRange &v) const
noexcept(noexcept(p_range != v.p_range)) {
bool operator!=(const EnumeratedRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
return p_range != v.p_range;
}
};
template<typename T>
EnumeratedRange<T> enumerate(const T &it)
noexcept(noexcept(EnumeratedRange<T>(it))) {
EnumeratedRange<T> enumerate(const T &it) noexcept(
noexcept(EnumeratedRange<T>(it))
) {
return EnumeratedRange<T>(it);
}
}

12
octa/utility.h
View File

@ -39,16 +39,18 @@ namespace octa {
/* swap */
template<typename T> void swap(T &a, T &b)
noexcept(IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value) {
template<typename T> void swap(T &a, T &b) noexcept(
IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
) {
T c(move(a));
a = move(b);
b = move(c);
}
template<typename T, size_t N> void swap(T (&a)[N], T (&b)[N])
noexcept(noexcept(swap(*a, *b))) {
template<typename T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(
noexcept(swap(*a, *b))
) {
for (size_t i = 0; i < N; ++i) {
swap(a[i], b[i]);
}

101
octa/vector.h
View File

@ -22,10 +22,11 @@ namespace octa {
T *p_buf;
size_t p_len, p_cap;
void insert_base(size_t idx, size_t n)
noexcept(IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value) {
void insert_base(size_t idx, size_t n) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
) {
if (p_len + n > p_cap) reserve(p_len + n);
p_len += n;
for (size_t i = p_len - 1; i > idx + n - 1; --i) {
@ -48,17 +49,19 @@ namespace octa {
Vector() noexcept: p_buf(nullptr), p_len(0), p_cap(0) {}
explicit Vector(size_t n, const T &val = T())
noexcept(IsNothrowCopyConstructible<T>::value): Vector() {
explicit Vector(size_t n, const T &val = T()) noexcept(
IsNothrowCopyConstructible<T>::value
): Vector() {
p_buf = new uchar[n * sizeof(T)];
p_len = p_cap = n;
T *cur = p_buf, *last = p_buf + n;
while (cur != last) new (cur++) T(val);
}
Vector(const Vector &v)
noexcept(IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value): Vector() {
Vector(const Vector &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value
): Vector() {
*this = v;
}
@ -68,8 +71,9 @@ namespace octa {
v.p_len = v.p_cap = 0;
}
Vector(InitializerList<T> v)
noexcept(IsNothrowCopyConstructible<T>::value): Vector() {
Vector(InitializerList<T> v) noexcept(
IsNothrowCopyConstructible<T>::value
): Vector() {
size_t len = v.length();
const T *ptr = v.get();
reserve(len);
@ -94,9 +98,10 @@ namespace octa {
}
}
Vector<T> &operator=(const Vector<T> &v)
noexcept(IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value) {
Vector<T> &operator=(const Vector<T> &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value
) {
if (this == &v) return *this;
if (p_cap >= v.p_cap) {
@ -125,8 +130,9 @@ namespace octa {
return *this;
}
Vector<T> &operator=(Vector<T> &&v)
noexcept(IsNothrowDestructible<T>::value) {
Vector<T> &operator=(Vector<T> &&v) noexcept(
IsNothrowDestructible<T>::value
) {
clear();
p_len = v.p_len;
p_cap = v.p_cap;
@ -134,10 +140,11 @@ namespace octa {
return *this;
}
void resize(size_t n, const T &v = T())
noexcept(IsNothrowDestructible<T>::value
void resize(size_t n, const T &v = T()) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowCopyConstructible<T>::value) {
&& IsNothrowCopyConstructible<T>::value
) {
size_t len = p_len;
reserve(n);
p_len = n;
@ -152,9 +159,10 @@ namespace octa {
}
}
void reserve(size_t n)
noexcept(IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value) {
void reserve(size_t n) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
) {
if (n <= p_len) {
if (n == p_len) return;
while (p_len > n) pop();
@ -189,15 +197,19 @@ namespace octa {
T &at(size_t i) noexcept { return p_buf[i]; }
const T &at(size_t i) const noexcept { return p_buf[i]; }
T &push(const T &v) noexcept(noexcept(reserve(p_len + 1))
&& IsNothrowCopyConstructible<T>::value) {
T &push(const T &v) noexcept(
noexcept(reserve(p_len + 1))
&& IsNothrowCopyConstructible<T>::value
) {
if (p_len == p_cap) reserve(p_len + 1);
new (&p_buf[p_len]) T(v);
return p_buf[p_len++];
}
T &push() noexcept(noexcept(reserve(p_len + 1))
&& IsNothrowDefaultConstructible<T>::value) {
T &push() noexcept(
noexcept(reserve(p_len + 1))
&& IsNothrowDefaultConstructible<T>::value
) {
if (p_len == p_cap) reserve(p_len + 1);
new (&p_buf[p_len]) T;
return p_buf[p_len++];
@ -249,24 +261,25 @@ namespace octa {
return r;
}
T *insert(size_t idx, T &&v)
noexcept(noexcept(insert_base(idx, 1))) {
T *insert(size_t idx, T &&v) noexcept(noexcept(insert_base(idx, 1))) {
insert_base(idx, 1);
p_buf[idx] = move(v);
return &p_buf[idx];
}
T *insert(size_t idx, const T &v)
noexcept(noexcept(insert_base(idx, 1))
&& IsNothrowCopyAssignable<T>::value) {
T *insert(size_t idx, const T &v) noexcept(
noexcept(insert_base(idx, 1))
&& IsNothrowCopyAssignable<T>::value
) {
insert_base(idx, 1);
p_buf[idx] = v;
return &p_buf[idx];
}
T *insert(size_t idx, size_t n, const T &v)
noexcept(noexcept(insert_base(idx, 1))
&& IsNothrowCopyAssignable<T>::value) {
T *insert(size_t idx, size_t n, const T &v) noexcept(
noexcept(insert_base(idx, 1))
&& IsNothrowCopyAssignable<T>::value
) {
insert_base(idx, n);
for (size_t i = 0; i < n; ++i) {
p_buf[idx + i] = v;
@ -275,13 +288,14 @@ namespace octa {
}
template<typename U>
T *insert_range(size_t idx, U range)
noexcept(IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
&& noexcept(range.first())
&& noexcept(range.pop_first())
&& noexcept((*p_buf = range.first()))) {
T *insert_range(size_t idx, U range) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
&& noexcept(range.first())
&& noexcept(range.pop_first())
&& noexcept((*p_buf = range.first()))
) {
size_t len = range.length();
insert_base(idx, len);
for (size_t i = 0; i < len; ++i) {
@ -291,8 +305,9 @@ namespace octa {
return &p_buf[idx];
}
T *insert(size_t idx, InitializerList<T> il)
noexcept(noexcept(insert_range(idx, il.range()))) {
T *insert(size_t idx, InitializerList<T> il) noexcept(
noexcept(insert_range(idx, il.range()))
) {
return insert_range(idx, il.range());
}