first -> front, last -> back
parent
ca5d80189a
commit
67600c4637
208
octa/algorithm.h
208
octa/algorithm.h
|
|
@ -20,10 +20,10 @@ namespace octa {
|
|||
template<typename R, typename U>
|
||||
R partition(R range, U pred) {
|
||||
R ret = range;
|
||||
for (; !range.empty(); range.pop_first()) {
|
||||
if (pred(range.first())) {
|
||||
swap(range.first(), ret.first());
|
||||
ret.pop_first();
|
||||
for (; !range.empty(); range.pop_front()) {
|
||||
if (pred(range.front())) {
|
||||
swap(range.front(), ret.front());
|
||||
ret.pop_front();
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
|
|
@ -31,9 +31,9 @@ namespace octa {
|
|||
|
||||
template<typename R, typename P>
|
||||
bool is_partitioned(R range, P pred) {
|
||||
for (; !range.empty() && pred(range.first()); range.pop_first());
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (pred(range.first())) return false;
|
||||
for (; !range.empty() && pred(range.front()); range.pop_front());
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (pred(range.front())) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -105,10 +105,10 @@ namespace octa {
|
|||
return;
|
||||
}
|
||||
RangeReference<R> p = range[range.size() / 2];
|
||||
swap(p, range.last());
|
||||
swap(p, range.back());
|
||||
R r = partition(range, __OctaUnaryCompare<decltype(p), C>{ p, compare });
|
||||
R l = range.slice(0, range.size() - r.size());
|
||||
swap(r.first(), r.last());
|
||||
swap(r.front(), r.back());
|
||||
__octa_introloop(l, compare, depth - 1);
|
||||
__octa_introloop(r, compare, depth - 1);
|
||||
}
|
||||
|
|
@ -152,16 +152,16 @@ namespace octa {
|
|||
template<typename R>
|
||||
inline R min_element(R range) {
|
||||
R r = range;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (min(r.first(), range.first()) == range.first())
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (min(r.front(), range.front()) == range.front())
|
||||
r = range;
|
||||
return r;
|
||||
}
|
||||
template<typename R, typename C>
|
||||
inline R min_element(R range, C compare) {
|
||||
R r = range;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (min(r.first(), range.first(), compare) == range.first())
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (min(r.front(), range.front(), compare) == range.front())
|
||||
r = range;
|
||||
return r;
|
||||
}
|
||||
|
|
@ -169,16 +169,16 @@ namespace octa {
|
|||
template<typename R>
|
||||
inline R max_element(R range) {
|
||||
R r = range;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (max(r.first(), range.first()) == range.first())
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (max(r.front(), range.front()) == range.front())
|
||||
r = range;
|
||||
return r;
|
||||
}
|
||||
template<typename R, typename C>
|
||||
inline R max_element(R range, C compare) {
|
||||
R r = range;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (max(r.first(), range.first(), compare) == range.first())
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (max(r.front(), range.front(), compare) == range.front())
|
||||
r = range;
|
||||
return r;
|
||||
}
|
||||
|
|
@ -187,21 +187,21 @@ namespace octa {
|
|||
|
||||
template<typename T>
|
||||
inline T min(initializer_list<T> il) {
|
||||
return min_element(each(il)).first();
|
||||
return min_element(each(il)).front();
|
||||
}
|
||||
template<typename T, typename C>
|
||||
inline T min(initializer_list<T> il, C compare) {
|
||||
return min_element(each(il), compare).first();
|
||||
return min_element(each(il), compare).front();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T max(initializer_list<T> il) {
|
||||
return max_element(each(il)).first();
|
||||
return max_element(each(il)).front();
|
||||
}
|
||||
|
||||
template<typename T, typename C>
|
||||
inline T max(initializer_list<T> il, C compare) {
|
||||
return max_element(each(il), compare).first();
|
||||
return max_element(each(il), compare).front();
|
||||
}
|
||||
|
||||
/* clamp */
|
||||
|
|
@ -220,52 +220,52 @@ namespace octa {
|
|||
|
||||
template<typename R, typename F>
|
||||
F for_each(R range, F func) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
func(range.first());
|
||||
for (; !range.empty(); range.pop_front())
|
||||
func(range.front());
|
||||
return move(func);
|
||||
}
|
||||
|
||||
template<typename R, typename P>
|
||||
bool all_of(R range, P pred) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (!pred(range.first())) return false;
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (!pred(range.front())) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename R, typename P>
|
||||
bool any_of(R range, P pred) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (pred(range.first())) return true;
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (pred(range.front())) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename R, typename P>
|
||||
bool none_of(R range, P pred) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (pred(range.first())) return false;
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (pred(range.front())) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename R, typename T>
|
||||
R find(R range, const T &v) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (range.first() == v)
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (range.front() == v)
|
||||
break;
|
||||
return range;
|
||||
}
|
||||
|
||||
template<typename R, typename P>
|
||||
R find_if(R range, P pred) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (pred(range.first()))
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (pred(range.front()))
|
||||
break;
|
||||
return range;
|
||||
}
|
||||
|
||||
template<typename R, typename P>
|
||||
R find_if_not(R range, P pred) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (!pred(range.first()))
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (!pred(range.front()))
|
||||
break;
|
||||
return range;
|
||||
}
|
||||
|
|
@ -273,8 +273,8 @@ namespace octa {
|
|||
template<typename R, typename T>
|
||||
RangeSize<R> count(R range, const T &v) {
|
||||
RangeSize<R> ret = 0;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (range.first() == v)
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (range.front() == v)
|
||||
++ret;
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -282,8 +282,8 @@ namespace octa {
|
|||
template<typename R, typename P>
|
||||
RangeSize<R> count_if(R range, P pred) {
|
||||
RangeSize<R> ret = 0;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (pred(range.first()))
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (pred(range.front()))
|
||||
++ret;
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -291,18 +291,18 @@ namespace octa {
|
|||
template<typename R, typename P>
|
||||
RangeSize<R> count_if_not(R range, P pred) {
|
||||
RangeSize<R> ret = 0;
|
||||
for (; !range.empty(); range.pop_first())
|
||||
if (!pred(range.first()))
|
||||
for (; !range.empty(); range.pop_front())
|
||||
if (!pred(range.front()))
|
||||
++ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename R>
|
||||
bool equal(R range1, R range2) {
|
||||
for (; !range1.empty(); range1.pop_first()) {
|
||||
if (range2.empty() || (range1.first() != range2.first()))
|
||||
for (; !range1.empty(); range1.pop_front()) {
|
||||
if (range2.empty() || (range1.front() != range2.front()))
|
||||
return false;
|
||||
range2.pop_first();
|
||||
range2.pop_front();
|
||||
}
|
||||
return range2.empty();
|
||||
}
|
||||
|
|
@ -311,103 +311,103 @@ namespace octa {
|
|||
|
||||
template<typename R1, typename R2>
|
||||
R2 copy(R1 irange, R2 orange) {
|
||||
for (; !irange.empty(); irange.pop_first())
|
||||
orange.put(irange.first());
|
||||
for (; !irange.empty(); irange.pop_front())
|
||||
orange.put(irange.front());
|
||||
return orange;
|
||||
}
|
||||
|
||||
template<typename R1, typename R2, typename P>
|
||||
R2 copy_if(R1 irange, R2 orange, P pred) {
|
||||
for (; !irange.empty(); irange.pop_first())
|
||||
if (pred(irange.first()))
|
||||
orange.put(irange.first());
|
||||
for (; !irange.empty(); irange.pop_front())
|
||||
if (pred(irange.front()))
|
||||
orange.put(irange.front());
|
||||
return orange;
|
||||
}
|
||||
|
||||
template<typename R1, typename R2, typename P>
|
||||
R2 copy_if_not(R1 irange, R2 orange, P pred) {
|
||||
for (; !irange.empty(); irange.pop_first())
|
||||
if (!pred(irange.first()))
|
||||
orange.put(irange.first());
|
||||
for (; !irange.empty(); irange.pop_front())
|
||||
if (!pred(irange.front()))
|
||||
orange.put(irange.front());
|
||||
return orange;
|
||||
}
|
||||
|
||||
template<typename R1, typename R2>
|
||||
R2 move(R1 irange, R2 orange) {
|
||||
for (; !irange.empty(); irange.pop_first())
|
||||
orange.put(move(irange.first()));
|
||||
for (; !irange.empty(); irange.pop_front())
|
||||
orange.put(move(irange.front()));
|
||||
return orange;
|
||||
}
|
||||
|
||||
template<typename R>
|
||||
void reverse(R range) {
|
||||
while (!range.empty()) {
|
||||
swap(range.first(), range.last());
|
||||
range.pop_first();
|
||||
range.pop_last();
|
||||
swap(range.front(), range.back());
|
||||
range.pop_front();
|
||||
range.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename R1, typename R2>
|
||||
R2 reverse_copy(R1 irange, R2 orange) {
|
||||
for (; !irange.empty(); irange.pop_last())
|
||||
orange.put(irange.last());
|
||||
for (; !irange.empty(); irange.pop_back())
|
||||
orange.put(irange.back());
|
||||
return orange;
|
||||
}
|
||||
|
||||
template<typename R, typename T>
|
||||
void fill(R range, const T &v) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
range.first() = v;
|
||||
for (; !range.empty(); range.pop_front())
|
||||
range.front() = v;
|
||||
}
|
||||
|
||||
template<typename R, typename F>
|
||||
void generate(R range, F gen) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
range.first() = gen();
|
||||
for (; !range.empty(); range.pop_front())
|
||||
range.front() = gen();
|
||||
}
|
||||
|
||||
template<typename R1, typename R2>
|
||||
Pair<R1, R2> swap_ranges(R1 range1, R2 range2) {
|
||||
while (!range1.empty() && !range2.empty()) {
|
||||
swap(range1.first(), range2.first());
|
||||
range1.pop_first();
|
||||
range2.pop_first();
|
||||
swap(range1.front(), range2.front());
|
||||
range1.pop_front();
|
||||
range2.pop_front();
|
||||
}
|
||||
return Pair<R1, R2>(range1, range2);
|
||||
}
|
||||
|
||||
template<typename R, typename T>
|
||||
void iota(R range, T value) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
range.first() = value++;
|
||||
for (; !range.empty(); range.pop_front())
|
||||
range.front() = value++;
|
||||
}
|
||||
|
||||
template<typename R, typename T>
|
||||
T foldl(R range, T init) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
init = init + range.first();
|
||||
for (; !range.empty(); range.pop_front())
|
||||
init = init + range.front();
|
||||
return init;
|
||||
}
|
||||
|
||||
template<typename R, typename T, typename F>
|
||||
T foldl(R range, T init, F func) {
|
||||
for (; !range.empty(); range.pop_first())
|
||||
init = func(init, range.first());
|
||||
for (; !range.empty(); range.pop_front())
|
||||
init = func(init, range.front());
|
||||
return init;
|
||||
}
|
||||
|
||||
template<typename R, typename T>
|
||||
T foldr(R range, T init) {
|
||||
for (; !range.empty(); range.pop_last())
|
||||
init = init + range.last();
|
||||
for (; !range.empty(); range.pop_back())
|
||||
init = init + range.back();
|
||||
return init;
|
||||
}
|
||||
|
||||
template<typename R, typename T, typename F>
|
||||
T foldr(R range, T init, F func) {
|
||||
for (; !range.empty(); range.pop_last())
|
||||
init = func(init, range.last());
|
||||
for (; !range.empty(); range.pop_back())
|
||||
init = func(init, range.back());
|
||||
return init;
|
||||
}
|
||||
|
||||
|
|
@ -440,34 +440,34 @@ namespace octa {
|
|||
bool empty() const { return p_range.empty(); }
|
||||
RangeSize<T> size() const { return p_range.size(); }
|
||||
|
||||
bool equals_first(const MapRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const MapRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
bool equals_last(const MapRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_back(const MapRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
RangeDifference<T> distance_first(const MapRange &range) const {
|
||||
return p_range.distance_first(range.p_range);
|
||||
RangeDifference<T> distance_front(const MapRange &range) const {
|
||||
return p_range.distance_front(range.p_range);
|
||||
}
|
||||
RangeDifference<T> distance_last(const MapRange &range) const {
|
||||
return p_range.distance_last(range.p_range);
|
||||
RangeDifference<T> distance_back(const MapRange &range) const {
|
||||
return p_range.distance_back(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() { return p_range.pop_first(); }
|
||||
bool pop_last() { return p_range.pop_last(); }
|
||||
bool pop_front() { return p_range.pop_front(); }
|
||||
bool pop_back() { return p_range.pop_back(); }
|
||||
|
||||
bool push_first() { return p_range.pop_first(); }
|
||||
bool push_last() { return p_range.push_last(); }
|
||||
bool push_front() { return p_range.pop_front(); }
|
||||
bool push_back() { return p_range.push_back(); }
|
||||
|
||||
RangeSize<T> pop_first_n(RangeSize<T> n) { p_range.pop_first_n(n); }
|
||||
RangeSize<T> pop_last_n(RangeSize<T> n) { p_range.pop_last_n(n); }
|
||||
RangeSize<T> pop_front_n(RangeSize<T> n) { p_range.pop_front_n(n); }
|
||||
RangeSize<T> pop_back_n(RangeSize<T> n) { p_range.pop_back_n(n); }
|
||||
|
||||
RangeSize<T> push_first_n(RangeSize<T> n) { return p_range.push_first_n(n); }
|
||||
RangeSize<T> push_last_n(RangeSize<T> n) { return p_range.push_last_n(n); }
|
||||
RangeSize<T> push_front_n(RangeSize<T> n) { return p_range.push_front_n(n); }
|
||||
RangeSize<T> push_back_n(RangeSize<T> n) { return p_range.push_back_n(n); }
|
||||
|
||||
R first() const { return p_func(p_range.first()); }
|
||||
R last() const { return p_func(p_range.last()); }
|
||||
R front() const { return p_func(p_range.front()); }
|
||||
R back() const { return p_func(p_range.back()); }
|
||||
|
||||
R operator[](RangeSize<T> idx) const {
|
||||
return p_func(p_range[idx]);
|
||||
|
|
@ -496,7 +496,7 @@ namespace octa {
|
|||
Function<bool(RangeReference<T>)> p_pred;
|
||||
|
||||
void advance_valid() {
|
||||
while (!p_range.empty() && !p_pred(first())) p_range.pop_first();
|
||||
while (!p_range.empty() && !p_pred(front())) p_range.pop_front();
|
||||
}
|
||||
|
||||
public:
|
||||
|
|
@ -531,26 +531,26 @@ namespace octa {
|
|||
|
||||
bool empty() const { return p_range.empty(); }
|
||||
|
||||
bool equals_first(const FilterRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const FilterRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() {
|
||||
bool ret = p_range.pop_first();
|
||||
bool pop_front() {
|
||||
bool ret = p_range.pop_front();
|
||||
advance_valid();
|
||||
return ret;
|
||||
}
|
||||
bool push_first() {
|
||||
bool push_front() {
|
||||
T tmp = p_range;
|
||||
if (!tmp.push_first()) return false;
|
||||
while (!pred(tmp.first()))
|
||||
if (!tmp.push_first())
|
||||
if (!tmp.push_front()) return false;
|
||||
while (!pred(tmp.front()))
|
||||
if (!tmp.push_front())
|
||||
return false;
|
||||
p_range = tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
RangeReference<T> first() const { return p_range.first(); }
|
||||
RangeReference<T> front() const { return p_range.front(); }
|
||||
};
|
||||
|
||||
template<typename R, typename P>
|
||||
|
|
|
|||
|
|
@ -31,11 +31,11 @@ namespace octa {
|
|||
T &at(size_t i) { return p_buf[i]; }
|
||||
const T &at(size_t i) const { return p_buf[i]; }
|
||||
|
||||
T &first() { return p_buf[0]; }
|
||||
const T &first() const { return p_buf[0]; }
|
||||
T &front() { return p_buf[0]; }
|
||||
const T &front() const { return p_buf[0]; }
|
||||
|
||||
T &last() { return p_buf[(N > 0) ? (N - 1) : 0]; }
|
||||
const T &last() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
|
||||
T &back() { return p_buf[(N > 0) ? (N - 1) : 0]; }
|
||||
const T &back() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
|
||||
|
||||
size_t size() const { return N; }
|
||||
|
||||
|
|
|
|||
242
octa/range.h
242
octa/range.h
|
|
@ -121,11 +121,11 @@ namespace octa {
|
|||
__OctaRangeIterator(): p_range() {}
|
||||
explicit __OctaRangeIterator(const T &range): p_range(range) {}
|
||||
__OctaRangeIterator &operator++() {
|
||||
p_range.pop_first();
|
||||
p_range.pop_front();
|
||||
return *this;
|
||||
}
|
||||
RangeReference<T> operator*() const {
|
||||
return p_range.first();
|
||||
return p_range.front();
|
||||
}
|
||||
bool operator!=(__OctaRangeIterator) const { return !p_range.empty(); }
|
||||
private:
|
||||
|
|
@ -158,26 +158,26 @@ namespace octa {
|
|||
|
||||
T range() const { return p_range; }
|
||||
|
||||
bool next() { return p_range.pop_first(); }
|
||||
bool prev() { return p_range.push_first(); }
|
||||
bool next() { return p_range.pop_front(); }
|
||||
bool prev() { return p_range.push_front(); }
|
||||
|
||||
RangeSize<T> next_n(RangeSize<T> n) {
|
||||
return p_range.pop_first_n(n);
|
||||
return p_range.pop_front_n(n);
|
||||
}
|
||||
RangeSize<T> prev_n(RangeSize<T> n) {
|
||||
return p_range.push_first_n(n);
|
||||
return p_range.push_front_n(n);
|
||||
}
|
||||
|
||||
RangeReference<T> get() const {
|
||||
return p_range.first();
|
||||
return p_range.front();
|
||||
}
|
||||
|
||||
RangeDifference<T> distance(const RangeHalf &half) const {
|
||||
return p_range.distance_first(half.p_range);
|
||||
return p_range.distance_front(half.p_range);
|
||||
}
|
||||
|
||||
bool equals(const RangeHalf &half) const {
|
||||
return p_range.equals_first(half.p_range);
|
||||
return p_range.equals_front(half.p_range);
|
||||
}
|
||||
|
||||
bool operator==(const RangeHalf &half) const {
|
||||
|
|
@ -248,30 +248,30 @@ namespace octa {
|
|||
}
|
||||
|
||||
template<typename R>
|
||||
RangeSize<R> __octa_pop_first_n(R &range, RangeSize<R> n) {
|
||||
RangeSize<R> __octa_pop_front_n(R &range, RangeSize<R> n) {
|
||||
for (RangeSize<R> i = 0; i < n; ++i)
|
||||
if (!range.pop_first()) return i;
|
||||
if (!range.pop_front()) return i;
|
||||
return n;
|
||||
}
|
||||
|
||||
template<typename R>
|
||||
RangeSize<R> __octa_pop_last_n(R &range, RangeSize<R> n) {
|
||||
RangeSize<R> __octa_pop_back_n(R &range, RangeSize<R> n) {
|
||||
for (RangeSize<R> i = 0; i < n; ++i)
|
||||
if (!range.pop_last()) return i;
|
||||
if (!range.pop_back()) return i;
|
||||
return n;
|
||||
}
|
||||
|
||||
template<typename R>
|
||||
RangeSize<R> __octa_push_first_n(R &range, RangeSize<R> n) {
|
||||
RangeSize<R> __octa_push_front_n(R &range, RangeSize<R> n) {
|
||||
for (RangeSize<R> i = 0; i < n; ++i)
|
||||
if (!range.push_first()) return i;
|
||||
if (!range.push_front()) return i;
|
||||
return n;
|
||||
}
|
||||
|
||||
template<typename R>
|
||||
RangeSize<R> __octa_push_last_n(R &range, RangeSize<R> n) {
|
||||
RangeSize<R> __octa_push_back_n(R &range, RangeSize<R> n) {
|
||||
for (RangeSize<R> i = 0; i < n; ++i)
|
||||
if (!range.push_last()) return i;
|
||||
if (!range.push_back()) return i;
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
@ -291,20 +291,20 @@ namespace octa {
|
|||
return __OctaRangeIterator<B>();
|
||||
}
|
||||
|
||||
SizeType pop_first_n(SizeType n) {
|
||||
return __octa_pop_first_n<B>(*((B *)this), n);
|
||||
SizeType pop_front_n(SizeType n) {
|
||||
return __octa_pop_front_n<B>(*((B *)this), n);
|
||||
}
|
||||
|
||||
SizeType pop_last_n(SizeType n) {
|
||||
return __octa_pop_last_n<B>(*((B *)this), n);
|
||||
SizeType pop_back_n(SizeType n) {
|
||||
return __octa_pop_back_n<B>(*((B *)this), n);
|
||||
}
|
||||
|
||||
SizeType push_first_n(SizeType n) {
|
||||
return __octa_push_first_n<B>(*((B *)this), n);
|
||||
SizeType push_front_n(SizeType n) {
|
||||
return __octa_push_front_n<B>(*((B *)this), n);
|
||||
}
|
||||
|
||||
SizeType push_last_n(SizeType n) {
|
||||
return __octa_push_last_n<B>(*((B *)this), n);
|
||||
SizeType push_back_n(SizeType n) {
|
||||
return __octa_push_back_n<B>(*((B *)this), n);
|
||||
}
|
||||
|
||||
B each() const {
|
||||
|
|
@ -366,34 +366,34 @@ namespace octa {
|
|||
bool empty() const { return p_range.empty(); }
|
||||
r_size size() const { return p_range.size(); }
|
||||
|
||||
bool equals_first(const ReverseRange &range) const {
|
||||
return p_range.equals_last(range.p_range);
|
||||
bool equals_front(const ReverseRange &range) const {
|
||||
return p_range.equals_back(range.p_range);
|
||||
}
|
||||
bool equals_last(const ReverseRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_back(const ReverseRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
RangeDifference<T> distance_first(const ReverseRange &range) const {
|
||||
return -p_range.distance_last(range.p_range);
|
||||
RangeDifference<T> distance_front(const ReverseRange &range) const {
|
||||
return -p_range.distance_back(range.p_range);
|
||||
}
|
||||
RangeDifference<T> distance_last(const ReverseRange &range) const {
|
||||
return -p_range.distance_first(range.p_range);
|
||||
RangeDifference<T> distance_back(const ReverseRange &range) const {
|
||||
return -p_range.distance_front(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() { return p_range.pop_last(); }
|
||||
bool pop_last() { return p_range.pop_first(); }
|
||||
bool pop_front() { return p_range.pop_back(); }
|
||||
bool pop_back() { return p_range.pop_front(); }
|
||||
|
||||
bool push_first() { return p_range.push_last(); }
|
||||
bool push_last() { return p_range.push_first(); }
|
||||
bool push_front() { return p_range.push_back(); }
|
||||
bool push_back() { return p_range.push_front(); }
|
||||
|
||||
r_size pop_first_n(r_size n) { return p_range.pop_first_n(n); }
|
||||
r_size pop_last_n(r_size n) { return p_range.pop_last_n(n); }
|
||||
r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); }
|
||||
r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); }
|
||||
|
||||
r_size push_first_n(r_size n) { return p_range.push_first_n(n); }
|
||||
r_size push_last_n(r_size n) { return p_range.push_last_n(n); }
|
||||
r_size push_front_n(r_size n) { return p_range.push_front_n(n); }
|
||||
r_size push_back_n(r_size n) { return p_range.push_back_n(n); }
|
||||
|
||||
r_ref first() const { return p_range.last(); }
|
||||
r_ref last() const { return p_range.first(); }
|
||||
r_ref front() const { return p_range.back(); }
|
||||
r_ref back() const { return p_range.front(); }
|
||||
|
||||
r_ref operator[](r_size i) const { return p_range[size() - i - 1]; }
|
||||
|
||||
|
|
@ -449,34 +449,34 @@ namespace octa {
|
|||
bool empty() const { return p_range.empty(); }
|
||||
r_size size() const { return p_range.size(); }
|
||||
|
||||
bool equals_first(const MoveRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const MoveRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
bool equals_last(const MoveRange &range) const {
|
||||
return p_range.equals_last(range.p_range);
|
||||
bool equals_back(const MoveRange &range) const {
|
||||
return p_range.equals_back(range.p_range);
|
||||
}
|
||||
|
||||
RangeDifference<T> distance_first(const MoveRange &range) const {
|
||||
return p_range.distance_first(range.p_range);
|
||||
RangeDifference<T> distance_front(const MoveRange &range) const {
|
||||
return p_range.distance_front(range.p_range);
|
||||
}
|
||||
RangeDifference<T> distance_last(const MoveRange &range) const {
|
||||
return p_range.distance_last(range.p_range);
|
||||
RangeDifference<T> distance_back(const MoveRange &range) const {
|
||||
return p_range.distance_back(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() { return p_range.pop_first(); }
|
||||
bool pop_last() { return p_range.pop_last(); }
|
||||
bool pop_front() { return p_range.pop_front(); }
|
||||
bool pop_back() { return p_range.pop_back(); }
|
||||
|
||||
bool push_first() { return p_range.push_first(); }
|
||||
bool push_last() { return p_range.push_last(); }
|
||||
bool push_front() { return p_range.push_front(); }
|
||||
bool push_back() { return p_range.push_back(); }
|
||||
|
||||
r_size pop_first_n(r_size n) { return p_range.pop_first_n(n); }
|
||||
r_size pop_last_n(r_size n) { return p_range.pop_last_n(n); }
|
||||
r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); }
|
||||
r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); }
|
||||
|
||||
r_size push_first_n(r_size n) { return p_range.push_first_n(n); }
|
||||
r_size push_last_n(r_size n) { return p_range.push_last_n(n); }
|
||||
r_size push_front_n(r_size n) { return p_range.push_front_n(n); }
|
||||
r_size push_back_n(r_size n) { return p_range.push_back_n(n); }
|
||||
|
||||
r_ref first() const { return move(p_range.first()); }
|
||||
r_ref last() const { return move(p_range.last()); }
|
||||
r_ref front() const { return move(p_range.front()); }
|
||||
r_ref back() const { return move(p_range.back()); }
|
||||
|
||||
r_ref operator[](r_size i) const { return move(p_range[i]); }
|
||||
|
||||
|
|
@ -504,13 +504,13 @@ namespace octa {
|
|||
|
||||
bool empty() const { return p_a * p_step >= p_b * p_step; }
|
||||
|
||||
bool equals_first(const NumberRange &range) const {
|
||||
bool equals_front(const NumberRange &range) const {
|
||||
return p_a == range.p_a;
|
||||
}
|
||||
|
||||
bool pop_first() { p_a += p_step; return true; }
|
||||
bool push_first() { p_a -= p_step; return true; }
|
||||
T first() const { return p_a; }
|
||||
bool pop_front() { p_a += p_step; return true; }
|
||||
bool push_front() { p_a -= p_step; return true; }
|
||||
T front() const { return p_a; }
|
||||
|
||||
private:
|
||||
T p_a, p_b, p_step;
|
||||
|
|
@ -543,16 +543,16 @@ namespace octa {
|
|||
/* satisfy InputRange / ForwardRange */
|
||||
bool empty() const { return p_beg == p_end; }
|
||||
|
||||
bool pop_first() {
|
||||
bool pop_front() {
|
||||
if (p_beg == p_end) return false;
|
||||
++p_beg;
|
||||
return true;
|
||||
}
|
||||
bool push_first() {
|
||||
bool push_front() {
|
||||
--p_beg; return true;
|
||||
}
|
||||
|
||||
size_t pop_first_n(size_t n) {
|
||||
size_t pop_front_n(size_t n) {
|
||||
T *obeg = p_beg;
|
||||
size_t olen = p_end - p_beg;
|
||||
p_beg += n;
|
||||
|
|
@ -563,31 +563,31 @@ namespace octa {
|
|||
return n;
|
||||
}
|
||||
|
||||
size_t push_first_n(size_t n) {
|
||||
size_t push_front_n(size_t n) {
|
||||
p_beg -= n; return true;
|
||||
}
|
||||
|
||||
T &first() const { return *p_beg; }
|
||||
T &front() const { return *p_beg; }
|
||||
|
||||
bool equals_first(const PointerRange &range) const {
|
||||
bool equals_front(const PointerRange &range) const {
|
||||
return p_beg == range.p_beg;
|
||||
}
|
||||
|
||||
ptrdiff_t distance_first(const PointerRange &range) const {
|
||||
ptrdiff_t distance_front(const PointerRange &range) const {
|
||||
return range.p_beg;
|
||||
}
|
||||
|
||||
/* satisfy BidirectionalRange */
|
||||
bool pop_last() {
|
||||
bool pop_back() {
|
||||
if (p_end == p_beg) return false;
|
||||
--p_end;
|
||||
return true;
|
||||
}
|
||||
bool push_last() {
|
||||
bool push_back() {
|
||||
++p_end; return true;
|
||||
}
|
||||
|
||||
size_t pop_last_n(size_t n) {
|
||||
size_t pop_back_n(size_t n) {
|
||||
T *oend = p_end;
|
||||
size_t olen = p_end - p_beg;
|
||||
p_end -= n;
|
||||
|
|
@ -598,17 +598,17 @@ namespace octa {
|
|||
return n;
|
||||
}
|
||||
|
||||
size_t push_last_n(size_t n) {
|
||||
size_t push_back_n(size_t n) {
|
||||
p_end += n; return true;
|
||||
}
|
||||
|
||||
T &last() const { return *(p_end - 1); }
|
||||
T &back() const { return *(p_end - 1); }
|
||||
|
||||
bool equals_last(const PointerRange &range) const {
|
||||
bool equals_back(const PointerRange &range) const {
|
||||
return p_end == range.p_end;
|
||||
}
|
||||
|
||||
ptrdiff_t distance_last(const PointerRange &range) const {
|
||||
ptrdiff_t distance_back(const PointerRange &range) const {
|
||||
return range.p_end;
|
||||
}
|
||||
|
||||
|
|
@ -686,26 +686,26 @@ namespace octa {
|
|||
|
||||
bool empty() const { return p_range.empty(); }
|
||||
|
||||
bool equals_first(const EnumeratedRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const EnumeratedRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() {
|
||||
if (p_range.pop_first()) {
|
||||
bool pop_front() {
|
||||
if (p_range.pop_front()) {
|
||||
++p_index;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
r_size pop_first_n(r_size n) {
|
||||
r_size ret = p_range.pop_first_n(n);
|
||||
r_size pop_front_n(r_size n) {
|
||||
r_size ret = p_range.pop_front_n(n);
|
||||
p_index += ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
EnumeratedValue<r_ref, r_size> first() const {
|
||||
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
|
||||
EnumeratedValue<r_ref, r_size> front() const {
|
||||
return EnumeratedValue<r_ref, r_size> { p_index, p_range.front() };
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -740,40 +740,40 @@ namespace octa {
|
|||
|
||||
bool empty() const { return (p_remaining <= 0) || p_range.empty(); }
|
||||
|
||||
bool pop_first() {
|
||||
if (p_range.pop_first()) {
|
||||
bool pop_front() {
|
||||
if (p_range.pop_front()) {
|
||||
--p_remaining;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool push_first() {
|
||||
if (p_range.push_first()) {
|
||||
bool push_front() {
|
||||
if (p_range.push_front()) {
|
||||
++p_remaining;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
RangeSize<T> pop_first_n(RangeSize<T> n) {
|
||||
RangeSize<T> ret = p_range.pop_first_n(n);
|
||||
RangeSize<T> pop_front_n(RangeSize<T> n) {
|
||||
RangeSize<T> ret = p_range.pop_front_n(n);
|
||||
p_remaining -= ret;
|
||||
return ret;
|
||||
}
|
||||
RangeSize<T> push_first_n(RangeSize<T> n) {
|
||||
RangeSize<T> ret = p_range.push_first_n(n);
|
||||
RangeSize<T> push_front_n(RangeSize<T> n) {
|
||||
RangeSize<T> ret = p_range.push_front_n(n);
|
||||
p_remaining += ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
RangeReference<T> first() const { return p_range.first(); }
|
||||
RangeReference<T> front() const { return p_range.front(); }
|
||||
|
||||
bool equals_first(const TakeRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const TakeRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
RangeDifference<T> distance_first(const TakeRange &range) const {
|
||||
return p_range.distance_first(range.p_range);
|
||||
RangeDifference<T> distance_front(const TakeRange &range) const {
|
||||
return p_range.distance_front(range.p_range);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -808,34 +808,34 @@ namespace octa {
|
|||
|
||||
bool empty() const { return p_range.empty(); }
|
||||
|
||||
bool equals_first(const ChunksRange &range) const {
|
||||
return p_range.equals_first(range.p_range);
|
||||
bool equals_front(const ChunksRange &range) const {
|
||||
return p_range.equals_front(range.p_range);
|
||||
}
|
||||
|
||||
bool pop_first() { return p_range.pop_first_n(p_chunksize) > 0; }
|
||||
bool push_first() {
|
||||
bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; }
|
||||
bool push_front() {
|
||||
T tmp = p_range;
|
||||
RangeSize<T> an = tmp.push_first_n(p_chunksize);
|
||||
RangeSize<T> an = tmp.push_front_n(p_chunksize);
|
||||
if (an != p_chunksize) return false;
|
||||
p_range = tmp;
|
||||
return true;
|
||||
}
|
||||
RangeSize<T> pop_first_n(RangeSize<T> n) {
|
||||
return p_range.pop_first_n(p_chunksize * n) / p_chunksize;
|
||||
RangeSize<T> pop_front_n(RangeSize<T> n) {
|
||||
return p_range.pop_front_n(p_chunksize * n) / p_chunksize;
|
||||
}
|
||||
RangeSize<T> push_first_n(RangeSize<T> n) {
|
||||
RangeSize<T> push_front_n(RangeSize<T> n) {
|
||||
T tmp = p_range;
|
||||
RangeSize<T> an = tmp.push_first_n(p_chunksize * n);
|
||||
RangeSize<T> an = tmp.push_front_n(p_chunksize * n);
|
||||
RangeSize<T> pn = an / p_chunksize;
|
||||
if (!pn) return 0;
|
||||
if (pn == n) {
|
||||
p_range = tmp;
|
||||
return pn;
|
||||
}
|
||||
return p_range.push_first_n(p_chunksize * an) / p_chunksize;
|
||||
return p_range.push_front_n(p_chunksize * an) / p_chunksize;
|
||||
}
|
||||
|
||||
TakeRange<T> first() const { return take(p_range, p_chunksize); }
|
||||
TakeRange<T> front() const { return take(p_range, p_chunksize); }
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
|
|
@ -892,35 +892,35 @@ namespace octa {
|
|||
|
||||
bool empty() const { return p_beg == p_end; }
|
||||
|
||||
bool pop_first() {
|
||||
bool pop_front() {
|
||||
if (empty()) return false;
|
||||
return p_beg.next();
|
||||
}
|
||||
bool push_first() {
|
||||
bool push_front() {
|
||||
return p_beg.prev();
|
||||
}
|
||||
bool pop_last() {
|
||||
bool pop_back() {
|
||||
if (empty()) return false;
|
||||
return p_end.prev();
|
||||
}
|
||||
bool push_last() {
|
||||
bool push_back() {
|
||||
return p_end.next();
|
||||
}
|
||||
|
||||
RangeReference<T> first() const { return *p_beg; }
|
||||
RangeReference<T> last() const { return *(p_end - 1); }
|
||||
RangeReference<T> front() const { return *p_beg; }
|
||||
RangeReference<T> back() const { return *(p_end - 1); }
|
||||
|
||||
bool equals_first(const HalfRange &range) const {
|
||||
bool equals_front(const HalfRange &range) const {
|
||||
return p_beg == range.p_beg;
|
||||
}
|
||||
bool equals_last(const HalfRange &range) const {
|
||||
bool equals_back(const HalfRange &range) const {
|
||||
return p_end == range.p_end;
|
||||
}
|
||||
|
||||
RangeDifference<T> distance_first(const HalfRange &range) const {
|
||||
RangeDifference<T> distance_front(const HalfRange &range) const {
|
||||
return range.p_beg - p_beg;
|
||||
}
|
||||
RangeDifference<T> distance_last(const HalfRange &range) const {
|
||||
RangeDifference<T> distance_back(const HalfRange &range) const {
|
||||
return range.p_end - p_end;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ namespace octa {
|
|||
Vector<T> p_buf;
|
||||
|
||||
void terminate() {
|
||||
if (p_buf.empty() || (p_buf.last() != '\0')) p_buf.push('\0');
|
||||
if (p_buf.empty() || (p_buf.back() != '\0')) p_buf.push('\0');
|
||||
}
|
||||
|
||||
public:
|
||||
|
|
@ -86,11 +86,11 @@ namespace octa {
|
|||
T &at(size_t i) { return p_buf[i]; }
|
||||
const T &at(size_t i) const { return p_buf[i]; }
|
||||
|
||||
T &first() { return p_buf[0]; }
|
||||
const T &first() const { return p_buf[0]; };
|
||||
T &front() { return p_buf[0]; }
|
||||
const T &front() const { return p_buf[0]; };
|
||||
|
||||
T &last() { return p_buf[size() - 1]; }
|
||||
const T &last() const { return p_buf[size() - 1]; }
|
||||
T &back() { return p_buf[size() - 1]; }
|
||||
const T &back() const { return p_buf[size() - 1]; }
|
||||
|
||||
T *data() { return p_buf.data(); }
|
||||
const T *data() const { return p_buf.data(); }
|
||||
|
|
@ -106,7 +106,7 @@ namespace octa {
|
|||
bool empty() const { return (size() == 0); }
|
||||
|
||||
void push(T v) {
|
||||
p_buf.last() = v;
|
||||
p_buf.back() = v;
|
||||
p_buf.push('\0');
|
||||
}
|
||||
|
||||
|
|
@ -186,8 +186,8 @@ namespace octa {
|
|||
auto range = each(v);
|
||||
if (range.empty()) return move(ret);
|
||||
for (;;) {
|
||||
ret += func(range.first());
|
||||
range.pop_first();
|
||||
ret += func(range.front());
|
||||
range.pop_front();
|
||||
if (range.empty()) break;
|
||||
ret += sep;
|
||||
}
|
||||
|
|
@ -200,8 +200,8 @@ namespace octa {
|
|||
auto range = each(v);
|
||||
if (range.empty()) return move(ret);
|
||||
for (;;) {
|
||||
ret += range.first();
|
||||
range.pop_first();
|
||||
ret += range.front();
|
||||
range.pop_front();
|
||||
if (range.empty()) break;
|
||||
ret += sep;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,8 +37,8 @@ namespace octa {
|
|||
RangeSize<R> len = range.size();
|
||||
reserve(len);
|
||||
p_len = len;
|
||||
for (size_t i = 0; !range.empty(); range.pop_first()) {
|
||||
new (&p_buf[i]) T(range.first());
|
||||
for (size_t i = 0; !range.empty(); range.pop_front()) {
|
||||
new (&p_buf[i]) T(range.front());
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
|
@ -48,9 +48,9 @@ namespace octa {
|
|||
::value, bool
|
||||
> = true) {
|
||||
size_t i = 0;
|
||||
for (; !range.empty(); range.pop_first()) {
|
||||
for (; !range.empty(); range.pop_front()) {
|
||||
reserve(i + 1);
|
||||
new (&p_buf[i]) T(range.first());
|
||||
new (&p_buf[i]) T(range.front());
|
||||
++i;
|
||||
p_len = i;
|
||||
}
|
||||
|
|
@ -236,11 +236,11 @@ namespace octa {
|
|||
}
|
||||
}
|
||||
|
||||
T &first() { return p_buf[0]; }
|
||||
const T &first() const { return p_buf[0]; };
|
||||
T &front() { return p_buf[0]; }
|
||||
const T &front() const { return p_buf[0]; };
|
||||
|
||||
T &last() { return p_buf[p_len - 1]; }
|
||||
const T &last() const { return p_buf[p_len - 1]; }
|
||||
T &back() { return p_buf[p_len - 1]; }
|
||||
const T &back() const { return p_buf[p_len - 1]; }
|
||||
|
||||
T *data() { return p_buf; }
|
||||
const T *data() const { return p_buf; }
|
||||
|
|
@ -288,8 +288,8 @@ namespace octa {
|
|||
size_t len = range.size();
|
||||
insert_base(idx, len);
|
||||
for (size_t i = 0; i < len; ++i) {
|
||||
p_buf[idx + i] = range.first();
|
||||
range.pop_first();
|
||||
p_buf[idx + i] = range.front();
|
||||
range.pop_front();
|
||||
}
|
||||
return &p_buf[idx];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ using namespace octa;
|
|||
int main() {
|
||||
Array<int, 5> x = { 2, 4, 8, 16, 32 };
|
||||
|
||||
assert(x.first() == 2);
|
||||
assert(x.last() == 32);
|
||||
assert(x.front() == 2);
|
||||
assert(x.back() == 32);
|
||||
|
||||
assert(x[0] == 2);
|
||||
assert(x[2] == 8);
|
||||
|
|
@ -28,14 +28,14 @@ int main() {
|
|||
assert(x.data()[0] == x[0]);
|
||||
|
||||
auto r = x.each();
|
||||
assert(r.first() == 2);
|
||||
assert(r.last() == 32);
|
||||
assert(r.front() == 2);
|
||||
assert(r.back() == 32);
|
||||
|
||||
Array<int, 5> z;
|
||||
x.swap(z);
|
||||
|
||||
assert(z.first() == 2);
|
||||
assert(z.last() == 32);
|
||||
assert(z.front() == 2);
|
||||
assert(z.back() == 32);
|
||||
|
||||
assert(z.size() == 5);
|
||||
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ using namespace octa;
|
|||
int main() {
|
||||
Vector<int> x = { 5, 10, 15, 20 };
|
||||
|
||||
assert(x.first() == 5);
|
||||
assert(x.last() == 20);
|
||||
assert(x.front() == 5);
|
||||
assert(x.back() == 20);
|
||||
|
||||
assert(x[0] == 5);
|
||||
assert(x[2] == 15);
|
||||
|
|
@ -24,13 +24,13 @@ int main() {
|
|||
Vector<int> y(5, 10);
|
||||
|
||||
assert(y.size() == 5);
|
||||
assert(y.first() == 10);
|
||||
assert(y.last() == 10);
|
||||
assert(y.front() == 10);
|
||||
assert(y.back() == 10);
|
||||
|
||||
Vector<int> z(x);
|
||||
|
||||
assert(x.first() == z.first());
|
||||
assert(x.last() == z.last());
|
||||
assert(x.front() == z.front());
|
||||
assert(x.back() == z.back());
|
||||
|
||||
z.clear();
|
||||
|
||||
|
|
@ -42,19 +42,19 @@ int main() {
|
|||
|
||||
assert(z.size() == 5);
|
||||
assert(y.size() == 0);
|
||||
assert(z.first() == 10);
|
||||
assert(z.last() == 10);
|
||||
assert(z.front() == 10);
|
||||
assert(z.back() == 10);
|
||||
|
||||
z.resize(150, 5);
|
||||
assert(z.size() == 150);
|
||||
assert(z.first() == 10);
|
||||
assert(z.last() == 5);
|
||||
assert(z.front() == 10);
|
||||
assert(z.back() == 5);
|
||||
|
||||
assert(z.push(30) == 30);
|
||||
assert(z.last() == 30);
|
||||
assert(z.back() == 30);
|
||||
|
||||
assert(z.emplace_back(20) == 20);
|
||||
assert(z.last() == 20);
|
||||
assert(z.back() == 20);
|
||||
|
||||
z.clear();
|
||||
z.resize(10, 5);
|
||||
|
|
@ -70,20 +70,20 @@ int main() {
|
|||
assert(z.size() == 11);
|
||||
|
||||
auto r = z.each();
|
||||
assert(r.first() == 5);
|
||||
assert(r.last() == 5);
|
||||
assert(r.front() == 5);
|
||||
assert(r.back() == 5);
|
||||
assert(r[2] == 4);
|
||||
|
||||
auto r2 = each(z);
|
||||
assert(r.first() == r2.first());
|
||||
assert(r.front() == r2.front());
|
||||
|
||||
Vector<int> w;
|
||||
w.swap(z);
|
||||
|
||||
assert(z.size() == 0);
|
||||
assert(w.size() != 0);
|
||||
assert(w.first() == 5);
|
||||
assert(w.last() == 5);
|
||||
assert(w.front() == 5);
|
||||
assert(w.back() == 5);
|
||||
|
||||
assert(!strcmp(to_string(w).data(), "{5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5}"));
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue