forked from OctaForge/libostd
noexcept formatting
parent
ef47ade61f
commit
b1192b248c
|
@ -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
200
octa/range.h
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
@ -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
|
||||
void insert_base(size_t idx, size_t n) noexcept(
|
||||
IsNothrowDestructible<T>::value
|
||||
&& IsNothrowMoveConstructible<T>::value
|
||||
&& IsNothrowMoveAssignable<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
|
||||
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()))) {
|
||||
&& 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());
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue