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

200
octa/range.h
View File

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

12
octa/utility.h
View File

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

101
octa/vector.h
View File

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