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

first -> front, last -> back

master
Daniel Kolesa 2015-06-01 01:13:37 +01:00
parent ca5d80189a
commit 67600c4637
7 changed files with 272 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
octa/algorithm.h
View File

@ -20,10 +20,10 @@ namespace octa {
template<typename R, typename U> template<typename R, typename U>
R partition(R range, U pred) { R partition(R range, U pred) {
R ret = range; R ret = range;
for (; !range.empty(); range.pop_first()) { for (; !range.empty(); range.pop_front()) {
if (pred(range.first())) { if (pred(range.front())) {
swap(range.first(), ret.first()); swap(range.front(), ret.front());
ret.pop_first(); ret.pop_front();
} }
} }
return ret; return ret;
@ -31,9 +31,9 @@ namespace octa {
template<typename R, typename P> template<typename R, typename P>
bool is_partitioned(R range, P pred) { bool is_partitioned(R range, P pred) {
for (; !range.empty() && pred(range.first()); range.pop_first()); for (; !range.empty() && pred(range.front()); range.pop_front());
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (pred(range.first())) return false; if (pred(range.front())) return false;
return true; return true;
} }
@ -105,10 +105,10 @@ namespace octa {
return; return;
} }
RangeReference<R> p = range[range.size() / 2]; 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 r = partition(range, __OctaUnaryCompare<decltype(p), C>{ p, compare });
R l = range.slice(0, range.size() - r.size()); 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(l, compare, depth - 1);
__octa_introloop(r, compare, depth - 1); __octa_introloop(r, compare, depth - 1);
} }
@ -152,16 +152,16 @@ namespace octa {
template<typename R> template<typename R>
inline R min_element(R range) { inline R min_element(R range) {
R r = range; R r = range;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (min(r.first(), range.first()) == range.first()) if (min(r.front(), range.front()) == range.front())
r = range; r = range;
return r; return r;
} }
template<typename R, typename C> template<typename R, typename C>
inline R min_element(R range, C compare) { inline R min_element(R range, C compare) {
R r = range; R r = range;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (min(r.first(), range.first(), compare) == range.first()) if (min(r.front(), range.front(), compare) == range.front())
r = range; r = range;
return r; return r;
} }
@ -169,16 +169,16 @@ namespace octa {
template<typename R> template<typename R>
inline R max_element(R range) { inline R max_element(R range) {
R r = range; R r = range;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (max(r.first(), range.first()) == range.first()) if (max(r.front(), range.front()) == range.front())
r = range; r = range;
return r; return r;
} }
template<typename R, typename C> template<typename R, typename C>
inline R max_element(R range, C compare) { inline R max_element(R range, C compare) {
R r = range; R r = range;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (max(r.first(), range.first(), compare) == range.first()) if (max(r.front(), range.front(), compare) == range.front())
r = range; r = range;
return r; return r;
} }
@ -187,21 +187,21 @@ namespace octa {
template<typename T> template<typename T>
inline T min(initializer_list<T> il) { inline T min(initializer_list<T> il) {
return min_element(each(il)).first(); return min_element(each(il)).front();
} }
template<typename T, typename C> template<typename T, typename C>
inline T min(initializer_list<T> il, C compare) { 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> template<typename T>
inline T max(initializer_list<T> il) { inline T max(initializer_list<T> il) {
return max_element(each(il)).first(); return max_element(each(il)).front();
} }
template<typename T, typename C> template<typename T, typename C>
inline T max(initializer_list<T> il, C compare) { inline T max(initializer_list<T> il, C compare) {
return max_element(each(il), compare).first(); return max_element(each(il), compare).front();
} }
/* clamp */ /* clamp */
@ -220,52 +220,52 @@ namespace octa {
template<typename R, typename F> template<typename R, typename F>
F for_each(R range, F func) { F for_each(R range, F func) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
func(range.first()); func(range.front());
return move(func); return move(func);
} }
template<typename R, typename P> template<typename R, typename P>
bool all_of(R range, P pred) { bool all_of(R range, P pred) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (!pred(range.first())) return false; if (!pred(range.front())) return false;
return true; return true;
} }
template<typename R, typename P> template<typename R, typename P>
bool any_of(R range, P pred) { bool any_of(R range, P pred) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (pred(range.first())) return true; if (pred(range.front())) return true;
return false; return false;
} }
template<typename R, typename P> template<typename R, typename P>
bool none_of(R range, P pred) { bool none_of(R range, P pred) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (pred(range.first())) return false; if (pred(range.front())) return false;
return true; return true;
} }
template<typename R, typename T> template<typename R, typename T>
R find(R range, const T &v) { R find(R range, const T &v) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (range.first() == v) if (range.front() == v)
break; break;
return range; return range;
} }
template<typename R, typename P> template<typename R, typename P>
R find_if(R range, P pred) { R find_if(R range, P pred) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (pred(range.first())) if (pred(range.front()))
break; break;
return range; return range;
} }
template<typename R, typename P> template<typename R, typename P>
R find_if_not(R range, P pred) { R find_if_not(R range, P pred) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (!pred(range.first())) if (!pred(range.front()))
break; break;
return range; return range;
} }
@ -273,8 +273,8 @@ namespace octa {
template<typename R, typename T> template<typename R, typename T>
RangeSize<R> count(R range, const T &v) { RangeSize<R> count(R range, const T &v) {
RangeSize<R> ret = 0; RangeSize<R> ret = 0;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (range.first() == v) if (range.front() == v)
++ret; ++ret;
return ret; return ret;
} }
@ -282,8 +282,8 @@ namespace octa {
template<typename R, typename P> template<typename R, typename P>
RangeSize<R> count_if(R range, P pred) { RangeSize<R> count_if(R range, P pred) {
RangeSize<R> ret = 0; RangeSize<R> ret = 0;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (pred(range.first())) if (pred(range.front()))
++ret; ++ret;
return ret; return ret;
} }
@ -291,18 +291,18 @@ namespace octa {
template<typename R, typename P> template<typename R, typename P>
RangeSize<R> count_if_not(R range, P pred) { RangeSize<R> count_if_not(R range, P pred) {
RangeSize<R> ret = 0; RangeSize<R> ret = 0;
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
if (!pred(range.first())) if (!pred(range.front()))
++ret; ++ret;
return ret; return ret;
} }
template<typename R> template<typename R>
bool equal(R range1, R range2) { bool equal(R range1, R range2) {
for (; !range1.empty(); range1.pop_first()) { for (; !range1.empty(); range1.pop_front()) {
if (range2.empty() || (range1.first() != range2.first())) if (range2.empty() || (range1.front() != range2.front()))
return false; return false;
range2.pop_first(); range2.pop_front();
} }
return range2.empty(); return range2.empty();
} }
@ -311,103 +311,103 @@ namespace octa {
template<typename R1, typename R2> template<typename R1, typename R2>
R2 copy(R1 irange, R2 orange) { R2 copy(R1 irange, R2 orange) {
for (; !irange.empty(); irange.pop_first()) for (; !irange.empty(); irange.pop_front())
orange.put(irange.first()); orange.put(irange.front());
return orange; return orange;
} }
template<typename R1, typename R2, typename P> template<typename R1, typename R2, typename P>
R2 copy_if(R1 irange, R2 orange, P pred) { R2 copy_if(R1 irange, R2 orange, P pred) {
for (; !irange.empty(); irange.pop_first()) for (; !irange.empty(); irange.pop_front())
if (pred(irange.first())) if (pred(irange.front()))
orange.put(irange.first()); orange.put(irange.front());
return orange; return orange;
} }
template<typename R1, typename R2, typename P> template<typename R1, typename R2, typename P>
R2 copy_if_not(R1 irange, R2 orange, P pred) { R2 copy_if_not(R1 irange, R2 orange, P pred) {
for (; !irange.empty(); irange.pop_first()) for (; !irange.empty(); irange.pop_front())
if (!pred(irange.first())) if (!pred(irange.front()))
orange.put(irange.first()); orange.put(irange.front());
return orange; return orange;
} }
template<typename R1, typename R2> template<typename R1, typename R2>
R2 move(R1 irange, R2 orange) { R2 move(R1 irange, R2 orange) {
for (; !irange.empty(); irange.pop_first()) for (; !irange.empty(); irange.pop_front())
orange.put(move(irange.first())); orange.put(move(irange.front()));
return orange; return orange;
} }
template<typename R> template<typename R>
void reverse(R range) { void reverse(R range) {
while (!range.empty()) { while (!range.empty()) {
swap(range.first(), range.last()); swap(range.front(), range.back());
range.pop_first(); range.pop_front();
range.pop_last(); range.pop_back();
} }
} }
template<typename R1, typename R2> template<typename R1, typename R2>
R2 reverse_copy(R1 irange, R2 orange) { R2 reverse_copy(R1 irange, R2 orange) {
for (; !irange.empty(); irange.pop_last()) for (; !irange.empty(); irange.pop_back())
orange.put(irange.last()); orange.put(irange.back());
return orange; return orange;
} }
template<typename R, typename T> template<typename R, typename T>
void fill(R range, const T &v) { void fill(R range, const T &v) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
range.first() = v; range.front() = v;
} }
template<typename R, typename F> template<typename R, typename F>
void generate(R range, F gen) { void generate(R range, F gen) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
range.first() = gen(); range.front() = gen();
} }
template<typename R1, typename R2> template<typename R1, typename R2>
Pair<R1, R2> swap_ranges(R1 range1, R2 range2) { Pair<R1, R2> swap_ranges(R1 range1, R2 range2) {
while (!range1.empty() && !range2.empty()) { while (!range1.empty() && !range2.empty()) {
swap(range1.first(), range2.first()); swap(range1.front(), range2.front());
range1.pop_first(); range1.pop_front();
range2.pop_first(); range2.pop_front();
} }
return Pair<R1, R2>(range1, range2); return Pair<R1, R2>(range1, range2);
} }
template<typename R, typename T> template<typename R, typename T>
void iota(R range, T value) { void iota(R range, T value) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
range.first() = value++; range.front() = value++;
} }
template<typename R, typename T> template<typename R, typename T>
T foldl(R range, T init) { T foldl(R range, T init) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
init = init + range.first(); init = init + range.front();
return init; return init;
} }
template<typename R, typename T, typename F> template<typename R, typename T, typename F>
T foldl(R range, T init, F func) { T foldl(R range, T init, F func) {
for (; !range.empty(); range.pop_first()) for (; !range.empty(); range.pop_front())
init = func(init, range.first()); init = func(init, range.front());
return init; return init;
} }
template<typename R, typename T> template<typename R, typename T>
T foldr(R range, T init) { T foldr(R range, T init) {
for (; !range.empty(); range.pop_last()) for (; !range.empty(); range.pop_back())
init = init + range.last(); init = init + range.back();
return init; return init;
} }
template<typename R, typename T, typename F> template<typename R, typename T, typename F>
T foldr(R range, T init, F func) { T foldr(R range, T init, F func) {
for (; !range.empty(); range.pop_last()) for (; !range.empty(); range.pop_back())
init = func(init, range.last()); init = func(init, range.back());
return init; return init;
} }
@ -440,34 +440,34 @@ namespace octa {
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
RangeSize<T> size() const { return p_range.size(); } RangeSize<T> size() const { return p_range.size(); }
bool equals_first(const MapRange &range) const { bool equals_front(const MapRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
bool equals_last(const MapRange &range) const { bool equals_back(const MapRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
RangeDifference<T> distance_first(const MapRange &range) const { RangeDifference<T> distance_front(const MapRange &range) const {
return p_range.distance_first(range.p_range); return p_range.distance_front(range.p_range);
} }
RangeDifference<T> distance_last(const MapRange &range) const { RangeDifference<T> distance_back(const MapRange &range) const {
return p_range.distance_last(range.p_range); return p_range.distance_back(range.p_range);
} }
bool pop_first() { return p_range.pop_first(); } bool pop_front() { return p_range.pop_front(); }
bool pop_last() { return p_range.pop_last(); } bool pop_back() { return p_range.pop_back(); }
bool push_first() { return p_range.pop_first(); } bool push_front() { return p_range.pop_front(); }
bool push_last() { return p_range.push_last(); } 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_front_n(RangeSize<T> n) { p_range.pop_front_n(n); }
RangeSize<T> pop_last_n(RangeSize<T> n) { p_range.pop_last_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_front_n(RangeSize<T> n) { return p_range.push_front_n(n); }
RangeSize<T> push_last_n(RangeSize<T> n) { return p_range.push_last_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 front() const { return p_func(p_range.front()); }
R last() const { return p_func(p_range.last()); } R back() const { return p_func(p_range.back()); }
R operator[](RangeSize<T> idx) const { R operator[](RangeSize<T> idx) const {
return p_func(p_range[idx]); return p_func(p_range[idx]);
@ -496,7 +496,7 @@ namespace octa {
Function<bool(RangeReference<T>)> p_pred; Function<bool(RangeReference<T>)> p_pred;
void advance_valid() { 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: public:
@ -531,26 +531,26 @@ namespace octa {
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_first(const FilterRange &range) const { bool equals_front(const FilterRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
bool pop_first() { bool pop_front() {
bool ret = p_range.pop_first(); bool ret = p_range.pop_front();
advance_valid(); advance_valid();
return ret; return ret;
} }
bool push_first() { bool push_front() {
T tmp = p_range; T tmp = p_range;
if (!tmp.push_first()) return false; if (!tmp.push_front()) return false;
while (!pred(tmp.first())) while (!pred(tmp.front()))
if (!tmp.push_first()) if (!tmp.push_front())
return false; return false;
p_range = tmp; p_range = tmp;
return true; return true;
} }
RangeReference<T> first() const { return p_range.first(); } RangeReference<T> front() const { return p_range.front(); }
}; };
template<typename R, typename P> template<typename R, typename P>

8
octa/array.h
View File

@ -31,11 +31,11 @@ namespace octa {
T &at(size_t i) { return p_buf[i]; } T &at(size_t i) { return p_buf[i]; }
const T &at(size_t i) const { return p_buf[i]; } const T &at(size_t i) const { return p_buf[i]; }
T &first() { return p_buf[0]; } T &front() { return p_buf[0]; }
const T &first() const { return p_buf[0]; } const T &front() const { return p_buf[0]; }
T &last() { return p_buf[(N > 0) ? (N - 1) : 0]; } T &back() { return p_buf[(N > 0) ? (N - 1) : 0]; }
const T &last() const { 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; } size_t size() const { return N; }

242
octa/range.h
View File

@ -121,11 +121,11 @@ namespace octa {
__OctaRangeIterator(): p_range() {} __OctaRangeIterator(): p_range() {}
explicit __OctaRangeIterator(const T &range): p_range(range) {} explicit __OctaRangeIterator(const T &range): p_range(range) {}
__OctaRangeIterator &operator++() { __OctaRangeIterator &operator++() {
p_range.pop_first(); p_range.pop_front();
return *this; return *this;
} }
RangeReference<T> operator*() const { RangeReference<T> operator*() const {
return p_range.first(); return p_range.front();
} }
bool operator!=(__OctaRangeIterator) const { return !p_range.empty(); } bool operator!=(__OctaRangeIterator) const { return !p_range.empty(); }
private: private:
@ -158,26 +158,26 @@ namespace octa {
T range() const { return p_range; } T range() const { return p_range; }
bool next() { return p_range.pop_first(); } bool next() { return p_range.pop_front(); }
bool prev() { return p_range.push_first(); } bool prev() { return p_range.push_front(); }
RangeSize<T> next_n(RangeSize<T> n) { 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) { 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 { RangeReference<T> get() const {
return p_range.first(); return p_range.front();
} }
RangeDifference<T> distance(const RangeHalf &half) const { 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 { 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 { bool operator==(const RangeHalf &half) const {
@ -248,30 +248,30 @@ namespace octa {
} }
template<typename R> 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) for (RangeSize<R> i = 0; i < n; ++i)
if (!range.pop_first()) return i; if (!range.pop_front()) return i;
return n; return n;
} }
template<typename R> 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) for (RangeSize<R> i = 0; i < n; ++i)
if (!range.pop_last()) return i; if (!range.pop_back()) return i;
return n; return n;
} }
template<typename R> 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) for (RangeSize<R> i = 0; i < n; ++i)
if (!range.push_first()) return i; if (!range.push_front()) return i;
return n; return n;
} }
template<typename R> 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) for (RangeSize<R> i = 0; i < n; ++i)
if (!range.push_last()) return i; if (!range.push_back()) return i;
return n; return n;
} }
@ -291,20 +291,20 @@ namespace octa {
return __OctaRangeIterator<B>(); return __OctaRangeIterator<B>();
} }
SizeType pop_first_n(SizeType n) { SizeType pop_front_n(SizeType n) {
return __octa_pop_first_n<B>(*((B *)this), n); return __octa_pop_front_n<B>(*((B *)this), n);
} }
SizeType pop_last_n(SizeType n) { SizeType pop_back_n(SizeType n) {
return __octa_pop_last_n<B>(*((B *)this), n); return __octa_pop_back_n<B>(*((B *)this), n);
} }
SizeType push_first_n(SizeType n) { SizeType push_front_n(SizeType n) {
return __octa_push_first_n<B>(*((B *)this), n); return __octa_push_front_n<B>(*((B *)this), n);
} }
SizeType push_last_n(SizeType n) { SizeType push_back_n(SizeType n) {
return __octa_push_last_n<B>(*((B *)this), n); return __octa_push_back_n<B>(*((B *)this), n);
} }
B each() const { B each() const {
@ -366,34 +366,34 @@ namespace octa {
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
r_size size() const { return p_range.size(); } r_size size() const { return p_range.size(); }
bool equals_first(const ReverseRange &range) const { bool equals_front(const ReverseRange &range) const {
return p_range.equals_last(range.p_range); return p_range.equals_back(range.p_range);
} }
bool equals_last(const ReverseRange &range) const { bool equals_back(const ReverseRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
RangeDifference<T> distance_first(const ReverseRange &range) const { RangeDifference<T> distance_front(const ReverseRange &range) const {
return -p_range.distance_last(range.p_range); return -p_range.distance_back(range.p_range);
} }
RangeDifference<T> distance_last(const ReverseRange &range) const { RangeDifference<T> distance_back(const ReverseRange &range) const {
return -p_range.distance_first(range.p_range); return -p_range.distance_front(range.p_range);
} }
bool pop_first() { return p_range.pop_last(); } bool pop_front() { return p_range.pop_back(); }
bool pop_last() { return p_range.pop_first(); } bool pop_back() { return p_range.pop_front(); }
bool push_first() { return p_range.push_last(); } bool push_front() { return p_range.push_back(); }
bool push_last() { return p_range.push_first(); } 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_front_n(r_size n) { return p_range.pop_front_n(n); }
r_size pop_last_n(r_size n) { return p_range.pop_last_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_front_n(r_size n) { return p_range.push_front_n(n); }
r_size push_last_n(r_size n) { return p_range.push_last_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 front() const { return p_range.back(); }
r_ref last() const { return p_range.first(); } r_ref back() const { return p_range.front(); }
r_ref operator[](r_size i) const { return p_range[size() - i - 1]; } 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(); } bool empty() const { return p_range.empty(); }
r_size size() const { return p_range.size(); } r_size size() const { return p_range.size(); }
bool equals_first(const MoveRange &range) const { bool equals_front(const MoveRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
bool equals_last(const MoveRange &range) const { bool equals_back(const MoveRange &range) const {
return p_range.equals_last(range.p_range); return p_range.equals_back(range.p_range);
} }
RangeDifference<T> distance_first(const MoveRange &range) const { RangeDifference<T> distance_front(const MoveRange &range) const {
return p_range.distance_first(range.p_range); return p_range.distance_front(range.p_range);
} }
RangeDifference<T> distance_last(const MoveRange &range) const { RangeDifference<T> distance_back(const MoveRange &range) const {
return p_range.distance_last(range.p_range); return p_range.distance_back(range.p_range);
} }
bool pop_first() { return p_range.pop_first(); } bool pop_front() { return p_range.pop_front(); }
bool pop_last() { return p_range.pop_last(); } bool pop_back() { return p_range.pop_back(); }
bool push_first() { return p_range.push_first(); } bool push_front() { return p_range.push_front(); }
bool push_last() { return p_range.push_last(); } 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_front_n(r_size n) { return p_range.pop_front_n(n); }
r_size pop_last_n(r_size n) { return p_range.pop_last_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_front_n(r_size n) { return p_range.push_front_n(n); }
r_size push_last_n(r_size n) { return p_range.push_last_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 front() const { return move(p_range.front()); }
r_ref last() const { return move(p_range.last()); } r_ref back() const { return move(p_range.back()); }
r_ref operator[](r_size i) const { return move(p_range[i]); } 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 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; return p_a == range.p_a;
} }
bool pop_first() { p_a += p_step; return true; } bool pop_front() { p_a += p_step; return true; }
bool push_first() { p_a -= p_step; return true; } bool push_front() { p_a -= p_step; return true; }
T first() const { return p_a; } T front() const { return p_a; }
private: private:
T p_a, p_b, p_step; T p_a, p_b, p_step;
@ -543,16 +543,16 @@ namespace octa {
/* satisfy InputRange / ForwardRange */ /* satisfy InputRange / ForwardRange */
bool empty() const { return p_beg == p_end; } bool empty() const { return p_beg == p_end; }
bool pop_first() { bool pop_front() {
if (p_beg == p_end) return false; if (p_beg == p_end) return false;
++p_beg; ++p_beg;
return true; return true;
} }
bool push_first() { bool push_front() {
--p_beg; return true; --p_beg; return true;
} }
size_t pop_first_n(size_t n) { size_t pop_front_n(size_t n) {
T *obeg = p_beg; T *obeg = p_beg;
size_t olen = p_end - p_beg; size_t olen = p_end - p_beg;
p_beg += n; p_beg += n;
@ -563,31 +563,31 @@ namespace octa {
return n; return n;
} }
size_t push_first_n(size_t n) { size_t push_front_n(size_t n) {
p_beg -= n; return true; 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; 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; return range.p_beg;
} }
/* satisfy BidirectionalRange */ /* satisfy BidirectionalRange */
bool pop_last() { bool pop_back() {
if (p_end == p_beg) return false; if (p_end == p_beg) return false;
--p_end; --p_end;
return true; return true;
} }
bool push_last() { bool push_back() {
++p_end; return true; ++p_end; return true;
} }
size_t pop_last_n(size_t n) { size_t pop_back_n(size_t n) {
T *oend = p_end; T *oend = p_end;
size_t olen = p_end - p_beg; size_t olen = p_end - p_beg;
p_end -= n; p_end -= n;
@ -598,17 +598,17 @@ namespace octa {
return n; return n;
} }
size_t push_last_n(size_t n) { size_t push_back_n(size_t n) {
p_end += n; return true; 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; 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; return range.p_end;
} }
@ -686,26 +686,26 @@ namespace octa {
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_first(const EnumeratedRange &range) const { bool equals_front(const EnumeratedRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
bool pop_first() { bool pop_front() {
if (p_range.pop_first()) { if (p_range.pop_front()) {
++p_index; ++p_index;
return true; return true;
} }
return false; return false;
} }
r_size pop_first_n(r_size n) { r_size pop_front_n(r_size n) {
r_size ret = p_range.pop_first_n(n); r_size ret = p_range.pop_front_n(n);
p_index += ret; p_index += ret;
return ret; return ret;
} }
EnumeratedValue<r_ref, r_size> first() const { EnumeratedValue<r_ref, r_size> front() const {
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() }; 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 empty() const { return (p_remaining <= 0) || p_range.empty(); }
bool pop_first() { bool pop_front() {
if (p_range.pop_first()) { if (p_range.pop_front()) {
--p_remaining; --p_remaining;
return true; return true;
} }
return false; return false;
} }
bool push_first() { bool push_front() {
if (p_range.push_first()) { if (p_range.push_front()) {
++p_remaining; ++p_remaining;
return true; return true;
} }
return false; return false;
} }
RangeSize<T> pop_first_n(RangeSize<T> n) { RangeSize<T> pop_front_n(RangeSize<T> n) {
RangeSize<T> ret = p_range.pop_first_n(n); RangeSize<T> ret = p_range.pop_front_n(n);
p_remaining -= ret; p_remaining -= ret;
return ret; return ret;
} }
RangeSize<T> push_first_n(RangeSize<T> n) { RangeSize<T> push_front_n(RangeSize<T> n) {
RangeSize<T> ret = p_range.push_first_n(n); RangeSize<T> ret = p_range.push_front_n(n);
p_remaining += ret; p_remaining += ret;
return 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 { bool equals_front(const TakeRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
RangeDifference<T> distance_first(const TakeRange &range) const { RangeDifference<T> distance_front(const TakeRange &range) const {
return p_range.distance_first(range.p_range); return p_range.distance_front(range.p_range);
} }
}; };
@ -808,34 +808,34 @@ namespace octa {
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_first(const ChunksRange &range) const { bool equals_front(const ChunksRange &range) const {
return p_range.equals_first(range.p_range); return p_range.equals_front(range.p_range);
} }
bool pop_first() { return p_range.pop_first_n(p_chunksize) > 0; } bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; }
bool push_first() { bool push_front() {
T tmp = p_range; 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; if (an != p_chunksize) return false;
p_range = tmp; p_range = tmp;
return true; return true;
} }
RangeSize<T> pop_first_n(RangeSize<T> n) { RangeSize<T> pop_front_n(RangeSize<T> n) {
return p_range.pop_first_n(p_chunksize * n) / p_chunksize; 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; 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; RangeSize<T> pn = an / p_chunksize;
if (!pn) return 0; if (!pn) return 0;
if (pn == n) { if (pn == n) {
p_range = tmp; p_range = tmp;
return pn; 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> template<typename T>
@ -892,35 +892,35 @@ namespace octa {
bool empty() const { return p_beg == p_end; } bool empty() const { return p_beg == p_end; }
bool pop_first() { bool pop_front() {
if (empty()) return false; if (empty()) return false;
return p_beg.next(); return p_beg.next();
} }
bool push_first() { bool push_front() {
return p_beg.prev(); return p_beg.prev();
} }
bool pop_last() { bool pop_back() {
if (empty()) return false; if (empty()) return false;
return p_end.prev(); return p_end.prev();
} }
bool push_last() { bool push_back() {
return p_end.next(); return p_end.next();
} }
RangeReference<T> first() const { return *p_beg; } RangeReference<T> front() const { return *p_beg; }
RangeReference<T> last() const { return *(p_end - 1); } 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; 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; 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; 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; return range.p_end - p_end;
} }

20
octa/string.h
View File

@ -23,7 +23,7 @@ namespace octa {
Vector<T> p_buf; Vector<T> p_buf;
void terminate() { 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: public:
@ -86,11 +86,11 @@ namespace octa {
T &at(size_t i) { return p_buf[i]; } T &at(size_t i) { return p_buf[i]; }
const T &at(size_t i) const { return p_buf[i]; } const T &at(size_t i) const { return p_buf[i]; }
T &first() { return p_buf[0]; } T &front() { return p_buf[0]; }
const T &first() const { return p_buf[0]; }; const T &front() const { return p_buf[0]; };
T &last() { return p_buf[size() - 1]; } T &back() { return p_buf[size() - 1]; }
const T &last() const { return p_buf[size() - 1]; } const T &back() const { return p_buf[size() - 1]; }
T *data() { return p_buf.data(); } T *data() { return p_buf.data(); }
const T *data() const { return p_buf.data(); } const T *data() const { return p_buf.data(); }
@ -106,7 +106,7 @@ namespace octa {
bool empty() const { return (size() == 0); } bool empty() const { return (size() == 0); }
void push(T v) { void push(T v) {
p_buf.last() = v; p_buf.back() = v;
p_buf.push('\0'); p_buf.push('\0');
} }
@ -186,8 +186,8 @@ namespace octa {
auto range = each(v); auto range = each(v);
if (range.empty()) return move(ret); if (range.empty()) return move(ret);
for (;;) { for (;;) {
ret += func(range.first()); ret += func(range.front());
range.pop_first(); range.pop_front();
if (range.empty()) break; if (range.empty()) break;
ret += sep; ret += sep;
} }
@ -200,8 +200,8 @@ namespace octa {
auto range = each(v); auto range = each(v);
if (range.empty()) return move(ret); if (range.empty()) return move(ret);
for (;;) { for (;;) {
ret += range.first(); ret += range.front();
range.pop_first(); range.pop_front();
if (range.empty()) break; if (range.empty()) break;
ret += sep; ret += sep;
} }

20
octa/vector.h
View File

@ -37,8 +37,8 @@ namespace octa {
RangeSize<R> len = range.size(); RangeSize<R> len = range.size();
reserve(len); reserve(len);
p_len = len; p_len = len;
for (size_t i = 0; !range.empty(); range.pop_first()) { for (size_t i = 0; !range.empty(); range.pop_front()) {
new (&p_buf[i]) T(range.first()); new (&p_buf[i]) T(range.front());
++i; ++i;
} }
} }
@ -48,9 +48,9 @@ namespace octa {
::value, bool ::value, bool
> = true) { > = true) {
size_t i = 0; size_t i = 0;
for (; !range.empty(); range.pop_first()) { for (; !range.empty(); range.pop_front()) {
reserve(i + 1); reserve(i + 1);
new (&p_buf[i]) T(range.first()); new (&p_buf[i]) T(range.front());
++i; ++i;
p_len = i; p_len = i;
} }
@ -236,11 +236,11 @@ namespace octa {
} }
} }
T &first() { return p_buf[0]; } T &front() { return p_buf[0]; }
const T &first() const { return p_buf[0]; }; const T &front() const { return p_buf[0]; };
T &last() { return p_buf[p_len - 1]; } T &back() { return p_buf[p_len - 1]; }
const T &last() const { return p_buf[p_len - 1]; } const T &back() const { return p_buf[p_len - 1]; }
T *data() { return p_buf; } T *data() { return p_buf; }
const T *data() const { return p_buf; } const T *data() const { return p_buf; }
@ -288,8 +288,8 @@ namespace octa {
size_t len = range.size(); size_t len = range.size();
insert_base(idx, len); insert_base(idx, len);
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
p_buf[idx + i] = range.first(); p_buf[idx + i] = range.front();
range.pop_first(); range.pop_front();
} }
return &p_buf[idx]; return &p_buf[idx];
} }

12
tests/array.cpp
View File

@ -8,8 +8,8 @@ using namespace octa;
int main() { int main() {
Array<int, 5> x = { 2, 4, 8, 16, 32 }; Array<int, 5> x = { 2, 4, 8, 16, 32 };
assert(x.first() == 2); assert(x.front() == 2);
assert(x.last() == 32); assert(x.back() == 32);
assert(x[0] == 2); assert(x[0] == 2);
assert(x[2] == 8); assert(x[2] == 8);
@ -28,14 +28,14 @@ int main() {
assert(x.data()[0] == x[0]); assert(x.data()[0] == x[0]);
auto r = x.each(); auto r = x.each();
assert(r.first() == 2); assert(r.front() == 2);
assert(r.last() == 32); assert(r.back() == 32);
Array<int, 5> z; Array<int, 5> z;
x.swap(z); x.swap(z);
assert(z.first() == 2); assert(z.front() == 2);
assert(z.last() == 32); assert(z.back() == 32);
assert(z.size() == 5); assert(z.size() == 5);

34
tests/vector.cpp
View File

@ -8,8 +8,8 @@ using namespace octa;
int main() { int main() {
Vector<int> x = { 5, 10, 15, 20 }; Vector<int> x = { 5, 10, 15, 20 };
assert(x.first() == 5); assert(x.front() == 5);
assert(x.last() == 20); assert(x.back() == 20);
assert(x[0] == 5); assert(x[0] == 5);
assert(x[2] == 15); assert(x[2] == 15);
@ -24,13 +24,13 @@ int main() {
Vector<int> y(5, 10); Vector<int> y(5, 10);
assert(y.size() == 5); assert(y.size() == 5);
assert(y.first() == 10); assert(y.front() == 10);
assert(y.last() == 10); assert(y.back() == 10);
Vector<int> z(x); Vector<int> z(x);
assert(x.first() == z.first()); assert(x.front() == z.front());
assert(x.last() == z.last()); assert(x.back() == z.back());
z.clear(); z.clear();
@ -42,19 +42,19 @@ int main() {
assert(z.size() == 5); assert(z.size() == 5);
assert(y.size() == 0); assert(y.size() == 0);
assert(z.first() == 10); assert(z.front() == 10);
assert(z.last() == 10); assert(z.back() == 10);
z.resize(150, 5); z.resize(150, 5);
assert(z.size() == 150); assert(z.size() == 150);
assert(z.first() == 10); assert(z.front() == 10);
assert(z.last() == 5); assert(z.back() == 5);
assert(z.push(30) == 30); assert(z.push(30) == 30);
assert(z.last() == 30); assert(z.back() == 30);
assert(z.emplace_back(20) == 20); assert(z.emplace_back(20) == 20);
assert(z.last() == 20); assert(z.back() == 20);
z.clear(); z.clear();
z.resize(10, 5); z.resize(10, 5);
@ -70,20 +70,20 @@ int main() {
assert(z.size() == 11); assert(z.size() == 11);
auto r = z.each(); auto r = z.each();
assert(r.first() == 5); assert(r.front() == 5);
assert(r.last() == 5); assert(r.back() == 5);
assert(r[2] == 4); assert(r[2] == 4);
auto r2 = each(z); auto r2 = each(z);
assert(r.first() == r2.first()); assert(r.front() == r2.front());
Vector<int> w; Vector<int> w;
w.swap(z); w.swap(z);
assert(z.size() == 0); assert(z.size() == 0);
assert(w.size() != 0); assert(w.size() != 0);
assert(w.first() == 5); assert(w.front() == 5);
assert(w.last() == 5); assert(w.back() == 5);
assert(!strcmp(to_string(w).data(), "{5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5}")); assert(!strcmp(to_string(w).data(), "{5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5}"));