From b1192b248cde0e3f669cd29c22ee4dff7ab95330 Mon Sep 17 00:00:00 2001 From: q66 Date: Wed, 29 Apr 2015 01:38:16 +0100 Subject: [PATCH] noexcept formatting --- octa/functional.h | 30 ++++--- octa/range.h | 200 ++++++++++++++++++++++++++-------------------- octa/utility.h | 12 +-- octa/vector.h | 101 +++++++++++++---------- 4 files changed, 198 insertions(+), 145 deletions(-) diff --git a/octa/functional.h b/octa/functional.h index ecbb353..cd91eef 100644 --- a/octa/functional.h +++ b/octa/functional.h @@ -16,8 +16,9 @@ namespace octa { #define __OCTA_DEFINE_BINARY_OP(name, op, rettype) \ template 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::value): p_fn(f) {} + explicit BinaryNegate(const T &f) noexcept( + IsNothrowCopyConstructible::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::value): p_fn(f) {} + explicit UnaryNegate(const T &f) noexcept( + IsNothrowCopyConstructible::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 UnaryNegate not1(const T &fn) - noexcept(IsNothrowCopyConstructible>::value) { + template UnaryNegate not1(const T &fn) noexcept( + IsNothrowCopyConstructible>::value + ) { return UnaryNegate(fn); } - template BinaryNegate not2(const T &fn) - noexcept(IsNothrowCopyConstructible>::value) { + template BinaryNegate not2(const T &fn) noexcept( + IsNothrowCopyConstructible>::value + ) { return BinaryNegate(fn); } diff --git a/octa/range.h b/octa/range.h index bc026e8..412343f 100644 --- a/octa/range.h +++ b/octa/range.h @@ -55,12 +55,14 @@ namespace octa { typedef V value_type; typedef R reference; - __OctaRangeIterator begin() - noexcept(IsNothrowCopyConstructible::value) { + __OctaRangeIterator begin() noexcept( + IsNothrowCopyConstructible::value + ) { return __OctaRangeIterator((const B &)*this); } - __OctaRangeIterator end() - noexcept(IsNothrowDefaultConstructible::value) { + __OctaRangeIterator end() noexcept( + IsNothrowDefaultConstructible::value + ) { return __OctaRangeIterator(); } }; @@ -87,36 +89,42 @@ namespace octa { T p_range; public: - ReverseRange() - noexcept(IsNothrowDefaultConstructible::value): p_range() {} + ReverseRange() noexcept(IsNothrowDefaultConstructible::value): + p_range() {} - ReverseRange(const T &range) - noexcept(IsNothrowCopyConstructible::value): p_range(range) {} + ReverseRange(const T &range) noexcept( + IsNothrowCopyConstructible::value + ): p_range(range) {} - ReverseRange(const ReverseRange &it) - noexcept(IsNothrowCopyConstructible::value): p_range(it.p_range) {} + ReverseRange(const ReverseRange &it) noexcept( + IsNothrowCopyConstructible::value + ): p_range(it.p_range) {} - ReverseRange(ReverseRange &&it) - noexcept(IsNothrowMoveConstructible::value): - p_range(move(it.p_range)) {} + ReverseRange(ReverseRange &&it) noexcept( + IsNothrowMoveConstructible::value + ): p_range(move(it.p_range)) {} - ReverseRange &operator=(const ReverseRange &v) - noexcept(IsNothrowCopyAssignable::value) { + ReverseRange &operator=(const ReverseRange &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v.p_range; return *this; } - ReverseRange &operator=(ReverseRange &&v) - noexcept(IsNothrowMoveAssignable::value) { + ReverseRange &operator=(ReverseRange &&v) noexcept( + IsNothrowMoveAssignable::value + ) { p_range = move(v.p_range); return *this; } - ReverseRange &operator=(const T &v) - noexcept(IsNothrowCopyAssignable::value) { + ReverseRange &operator=(const T &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v; return *this; } - ReverseRange &operator=(T &&v) - noexcept(IsNothrowMoveAssignable::value) { + ReverseRange &operator=(T &&v) noexcept( + IsNothrowMoveAssignable::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 slice(r_size start, r_size end) - noexcept(noexcept(ReverseRange(p_range.slice(0, 0))) - && noexcept(p_range.length())) { + ReverseRange slice(r_size start, r_size end) noexcept( + noexcept(ReverseRange(p_range.slice(0, 0))) + && noexcept(p_range.length()) + ) { r_size len = p_range.length(); return ReverseRange(p_range.slice(len - end, len - start)); } }; template - ReverseRange make_reverse_range(const T &it) - noexcept(noexcept(ReverseRange(it))) { + ReverseRange make_reverse_range(const T &it) noexcept( + noexcept(ReverseRange(it)) + ) { return ReverseRange(it); } @@ -195,36 +207,42 @@ namespace octa { T p_range; public: - MoveRange() - noexcept(IsNothrowDefaultConstructible::value): p_range() {} + MoveRange() noexcept(IsNothrowDefaultConstructible::value): + p_range() {} - MoveRange(const T &range) - noexcept(IsNothrowCopyConstructible::value): p_range(range) {} + MoveRange(const T &range) noexcept( + IsNothrowCopyConstructible::value + ): p_range(range) {} - MoveRange(const MoveRange &it) - noexcept(IsNothrowCopyConstructible::value): p_range(it.p_range) {} + MoveRange(const MoveRange &it) noexcept( + IsNothrowCopyConstructible::value + ): p_range(it.p_range) {} - MoveRange(MoveRange &&it) - noexcept(IsNothrowMoveConstructible::value): - p_range(move(it.p_range)) {} + MoveRange(MoveRange &&it) noexcept( + IsNothrowMoveConstructible::value + ): p_range(move(it.p_range)) {} - MoveRange &operator=(const MoveRange &v) - noexcept(IsNothrowCopyAssignable::value) { + MoveRange &operator=(const MoveRange &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v.p_range; return *this; } - MoveRange &operator=(MoveRange &&v) - noexcept(IsNothrowMoveAssignable::value) { + MoveRange &operator=(MoveRange &&v) noexcept( + IsNothrowMoveAssignable::value + ) { p_range = move(v.p_range); return *this; } - MoveRange &operator=(const T &v) - noexcept(IsNothrowCopyAssignable::value) { + MoveRange &operator=(const T &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v; return *this; } - MoveRange &operator=(T &&v) - noexcept(IsNothrowMoveAssignable::value) { + MoveRange &operator=(T &&v) noexcept( + IsNothrowMoveAssignable::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 slice(r_size start, r_size end) - noexcept(noexcept(MoveRange(p_range.slice(start, end)))) { + MoveRange slice(r_size start, r_size end) noexcept( + noexcept(MoveRange(p_range.slice(start, end))) + ) { return MoveRange(p_range.slice(start, end)); } @@ -274,8 +295,9 @@ namespace octa { }; template - MoveRange make_move_range(const T &it) - noexcept(noexcept(MoveRange(it))) { + MoveRange make_move_range(const T &it) noexcept( + noexcept(MoveRange(it)) + ) { return MoveRange(it); } @@ -388,42 +410,45 @@ namespace octa { r_size p_index; public: - EnumeratedRange() - noexcept(IsNothrowDefaultConstructible::value): p_range(), - p_index(0) {} + EnumeratedRange() noexcept(IsNothrowDefaultConstructible::value): + p_range(), p_index(0) {} - EnumeratedRange(const T &range) - noexcept(IsNothrowCopyConstructible::value): p_range(range), - p_index(0) {} + EnumeratedRange(const T &range) noexcept( + IsNothrowCopyConstructible::value + ): p_range(range), p_index(0) {} - EnumeratedRange(const EnumeratedRange &it) - noexcept(IsNothrowCopyConstructible::value): p_range(it.p_range), - p_index(it.p_index) {} + EnumeratedRange(const EnumeratedRange &it) noexcept( + IsNothrowCopyConstructible::value + ): p_range(it.p_range), p_index(it.p_index) {} - EnumeratedRange(EnumeratedRange &&it) - noexcept(IsNothrowMoveConstructible::value): - p_range(move(it.p_range)), p_index(it.p_index) {} + EnumeratedRange(EnumeratedRange &&it) noexcept( + IsNothrowMoveConstructible::value + ): p_range(move(it.p_range)), p_index(it.p_index) {} - EnumeratedRange &operator=(const EnumeratedRange &v) - noexcept(IsNothrowCopyAssignable::value) { + EnumeratedRange &operator=(const EnumeratedRange &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v.p_range; p_index = v.p_index; return *this; } - EnumeratedRange &operator=(EnumeratedRange &&v) - noexcept(IsNothrowMoveAssignable::value) { + EnumeratedRange &operator=(EnumeratedRange &&v) noexcept( + IsNothrowMoveAssignable::value + ) { p_range = move(v.p_range); p_index = v.p_index; return *this; } - EnumeratedRange &operator=(const T &v) - noexcept(IsNothrowCopyAssignable::value) { + EnumeratedRange &operator=(const T &v) noexcept( + IsNothrowCopyAssignable::value + ) { p_range = v; p_index = 0; return *this; } - EnumeratedRange &operator=(T &&v) - noexcept(IsNothrowMoveAssignable::value) { + EnumeratedRange &operator=(T &&v) noexcept( + IsNothrowMoveAssignable::value + ) { p_range = move(v); p_index = 0; return *this; @@ -437,28 +462,33 @@ namespace octa { ++p_index; p_range.pop_first(); } - EnumeratedValue first() - noexcept(noexcept(p_range.first())) { + EnumeratedValue first() noexcept( + noexcept(p_range.first()) + ) { return EnumeratedValue { p_index, p_range.first() }; } - EnumeratedValue first() const - noexcept(noexcept(p_range.first())) { + EnumeratedValue first() const noexcept( + noexcept(p_range.first()) + ) { return EnumeratedValue { 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 - EnumeratedRange enumerate(const T &it) - noexcept(noexcept(EnumeratedRange(it))) { + EnumeratedRange enumerate(const T &it) noexcept( + noexcept(EnumeratedRange(it)) + ) { return EnumeratedRange(it); } } diff --git a/octa/utility.h b/octa/utility.h index bcb74e8..e74861a 100644 --- a/octa/utility.h +++ b/octa/utility.h @@ -39,16 +39,18 @@ namespace octa { /* swap */ - template void swap(T &a, T &b) - noexcept(IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value) { + template void swap(T &a, T &b) noexcept( + IsNothrowMoveConstructible::value + && IsNothrowMoveAssignable::value + ) { T c(move(a)); a = move(b); b = move(c); } - template void swap(T (&a)[N], T (&b)[N]) - noexcept(noexcept(swap(*a, *b))) { + template 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]); } diff --git a/octa/vector.h b/octa/vector.h index 5cf2def..d5016db 100644 --- a/octa/vector.h +++ b/octa/vector.h @@ -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::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value) { + void insert_base(size_t idx, size_t n) noexcept( + IsNothrowDestructible::value + && IsNothrowMoveConstructible::value + && IsNothrowMoveAssignable::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::value): Vector() { + explicit Vector(size_t n, const T &val = T()) noexcept( + IsNothrowCopyConstructible::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::value - && IsNothrowCopyConstructible::value): Vector() { + Vector(const Vector &v) noexcept( + IsNothrowDestructible::value + && IsNothrowCopyConstructible::value + ): Vector() { *this = v; } @@ -68,8 +71,9 @@ namespace octa { v.p_len = v.p_cap = 0; } - Vector(InitializerList v) - noexcept(IsNothrowCopyConstructible::value): Vector() { + Vector(InitializerList v) noexcept( + IsNothrowCopyConstructible::value + ): Vector() { size_t len = v.length(); const T *ptr = v.get(); reserve(len); @@ -94,9 +98,10 @@ namespace octa { } } - Vector &operator=(const Vector &v) - noexcept(IsNothrowDestructible::value - && IsNothrowCopyConstructible::value) { + Vector &operator=(const Vector &v) noexcept( + IsNothrowDestructible::value + && IsNothrowCopyConstructible::value + ) { if (this == &v) return *this; if (p_cap >= v.p_cap) { @@ -125,8 +130,9 @@ namespace octa { return *this; } - Vector &operator=(Vector &&v) - noexcept(IsNothrowDestructible::value) { + Vector &operator=(Vector &&v) noexcept( + IsNothrowDestructible::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::value + void resize(size_t n, const T &v = T()) noexcept( + IsNothrowDestructible::value && IsNothrowMoveConstructible::value - && IsNothrowCopyConstructible::value) { + && IsNothrowCopyConstructible::value + ) { size_t len = p_len; reserve(n); p_len = n; @@ -152,9 +159,10 @@ namespace octa { } } - void reserve(size_t n) - noexcept(IsNothrowDestructible::value - && IsNothrowMoveConstructible::value) { + void reserve(size_t n) noexcept( + IsNothrowDestructible::value + && IsNothrowMoveConstructible::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::value) { + T &push(const T &v) noexcept( + noexcept(reserve(p_len + 1)) + && IsNothrowCopyConstructible::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::value) { + T &push() noexcept( + noexcept(reserve(p_len + 1)) + && IsNothrowDefaultConstructible::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::value) { + T *insert(size_t idx, const T &v) noexcept( + noexcept(insert_base(idx, 1)) + && IsNothrowCopyAssignable::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::value) { + T *insert(size_t idx, size_t n, const T &v) noexcept( + noexcept(insert_base(idx, 1)) + && IsNothrowCopyAssignable::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 - T *insert_range(size_t idx, U range) - noexcept(IsNothrowDestructible::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value - && noexcept(range.first()) - && noexcept(range.pop_first()) - && noexcept((*p_buf = range.first()))) { + T *insert_range(size_t idx, U range) noexcept( + IsNothrowDestructible::value + && IsNothrowMoveConstructible::value + && IsNothrowMoveAssignable::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 il) - noexcept(noexcept(insert_range(idx, il.range()))) { + T *insert(size_t idx, InitializerList il) noexcept( + noexcept(insert_range(idx, il.range())) + ) { return insert_range(idx, il.range()); }