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

use size() instead of length()

master
Daniel Kolesa 2015-05-27 23:19:16 +01:00
parent d2ddb82499
commit 1371a32db7
6 changed files with 37 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
octa/algorithm.h
View File

@ -41,7 +41,7 @@ namespace octa {
template<typename R, typename C>
void __octa_insort(R range, C compare) {
RangeSize<R> rlen = range.length();
RangeSize<R> rlen = range.size();
for (RangeSize<R> i = 1; i < rlen; ++i) {
RangeSize<R> j = i;
RangeReference<R> v = range[i];
@ -80,7 +80,7 @@ namespace octa {
template<typename R, typename C>
void __octa_heapsort(R range, C compare) {
RangeSize<R> len = range.length();
RangeSize<R> len = range.size();
RangeSize<R> st = (len - 2) / 2;
for (;;) {
__octa_hs_sift_down(range, st, len - 1, compare);
@ -96,7 +96,7 @@ namespace octa {
template<typename R, typename C>
void __octa_introloop(R range, C compare, RangeSize<R> depth) {
if (range.length() <= 10) {
if (range.size() <= 10) {
__octa_insort(range, compare);
return;
}
@ -104,10 +104,10 @@ namespace octa {
__octa_heapsort(range, compare);
return;
}
RangeReference<R> p = range[range.length() / 2];
RangeReference<R> p = range[range.size() / 2];
swap(p, range.last());
R r = partition(range, __OctaUnaryCompare<decltype(p), C>{ p, compare });
R l = range.slice(0, range.length() - r.length());
R l = range.slice(0, range.size() - r.size());
swap(r.first(), r.last());
__octa_introloop(l, compare, depth - 1);
__octa_introloop(r, compare, depth - 1);
@ -116,7 +116,7 @@ namespace octa {
template<typename R, typename C>
void __octa_introsort(R range, C compare) {
__octa_introloop(range, compare, RangeSize<R>(2
* (log(range.length()) / log(2))));
* (log(range.size()) / log(2))));
}
template<typename R, typename C>
@ -436,7 +436,7 @@ namespace octa {
}
bool empty() const { return p_range.empty(); }
RangeSize<T> length() const { return p_range.length(); }
RangeSize<T> size() const { return p_range.size(); }
void pop_first() { p_range.pop_first(); }
void pop_last() { p_range.pop_last(); }

2
octa/array.h
View File

@ -36,7 +36,7 @@ namespace octa {
T &last() { return p_buf[(N > 0) ? (N - 1) : 0]; }
const T &last() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
size_t length() const { return N; }
size_t size() const { return N; }
bool empty() const { return N == 0; }

2
octa/initializer_list.h
View File

@ -31,7 +31,7 @@ namespace std {
initializer_list(): p_buf(nullptr), p_len(0) {}
size_t length() const { return p_len; }
size_t size() const { return p_len; }
const T *data() const { return p_buf; }

26
octa/range.h
View File

@ -208,8 +208,8 @@ namespace octa {
return p_range.empty();
}
r_size length() const {
return p_range.length();
r_size size() const {
return p_range.size();
}
void pop_first() {
@ -248,14 +248,14 @@ namespace octa {
}
r_ref operator[](r_size i) {
return p_range[length() - i - 1];
return p_range[size() - i - 1];
}
r_ref operator[](r_size i) const {
return p_range[length() - i - 1];
return p_range[size() - i - 1];
}
ReverseRange<T> slice(r_size start, r_size end) {
r_size len = p_range.length();
r_size len = p_range.size();
return ReverseRange<T>(p_range.slice(len - end, len - start));
}
};
@ -305,8 +305,8 @@ namespace octa {
bool empty() const {
return p_range.empty();
}
r_size length() const {
return p_range.length();
r_size size() const {
return p_range.size();
}
void pop_first() {
@ -456,7 +456,7 @@ namespace octa {
const T &last() const { return *(p_end - 1); }
/* satisfy FiniteRandomAccessRange */
size_t length() const { return p_end - p_beg; }
size_t size() const { return p_end - p_beg; }
PointerRange slice(size_t start, size_t end) {
return PointerRange(p_beg + start, p_beg + end);
@ -598,10 +598,10 @@ namespace octa {
RangeReference<T> first() { return p_range.first(); }
RangeReference<T> first() const { return p_range.first(); }
RangeSize<T> length() const {
RangeSize<T> size() const {
if (p_remaining <= 0) return 0;
if (IsFiniteRandomAccessRange<T>::value) {
RangeSize<T> ol = p_range.length();
RangeSize<T> ol = p_range.size();
return (ol > p_remaining) ? p_remaining : ol;
}
return p_remaining;
@ -615,7 +615,7 @@ namespace octa {
RangeSize<T> pop_last_n(RangeSize<T> n) {
static_assert(IsRandomAccessRange<T>::value,
"pop_last_n() only available for random access ranges");
RangeSize<T> ol = length();
RangeSize<T> ol = size();
p_remaining -= n;
return (ol < n) ? ol : n;
}
@ -623,12 +623,12 @@ namespace octa {
RangeReference<T> last() {
static_assert(IsRandomAccessRange<T>::value,
"last() only available for random access ranges");
return p_range[length() - 1];
return p_range[size() - 1];
}
RangeReference<T> last() const {
static_assert(IsRandomAccessRange<T>::value,
"last() only available for random access ranges");
return p_range[length() - 1];
return p_range[size() - 1];
}
RangeReference<T> operator[](RangeSize<T> idx) {

20
octa/string.h
View File

@ -42,7 +42,7 @@ namespace octa {
StringBase(const StringBase &s, size_t pos, size_t len = npos):
p_buf(s.p_buf.each().slice(pos,
(len == npos) ? s.p_buf.length() : (pos + len))) {
(len == npos) ? s.p_buf.size() : (pos + len))) {
terminate();
}
@ -77,21 +77,21 @@ namespace octa {
T &first() { return p_buf[0]; }
const T &first() const { return p_buf[0]; };
T &last() { return p_buf[length() - 1]; }
const T &last() const { return p_buf[length() - 1]; }
T &last() { return p_buf[size() - 1]; }
const T &last() const { return p_buf[size() - 1]; }
T *data() { return p_buf.data(); }
const T *data() const { return p_buf.data(); }
size_t length() const {
return p_buf.length() - 1;
size_t size() const {
return p_buf.size() - 1;
}
size_t capacity() const {
return p_buf.capacity() - 1;
}
bool empty() const { return (length() == 0); }
bool empty() const { return (size() == 0); }
void push(T v) {
p_buf.last() = v;
@ -100,12 +100,12 @@ namespace octa {
StringBase<T> &operator+=(const StringBase &s) {
p_buf.pop();
p_buf.insert_range(p_buf.length(), s.p_buf.each());
p_buf.insert_range(p_buf.size(), s.p_buf.each());
return *this;
}
StringBase<T> &operator+=(const T *s) {
p_buf.pop();
p_buf.insert_range(p_buf.length(), PointerRange<const T>(s,
p_buf.insert_range(p_buf.size(), PointerRange<const T>(s,
strlen(s) + 1));
return *this;
}
@ -117,10 +117,10 @@ namespace octa {
}
RangeType each() {
return PointerRange<T>(p_buf.data(), length());
return PointerRange<T>(p_buf.data(), size());
}
ConstRangeType each() const {
return PointerRange<const T>(p_buf.data(), length());
return PointerRange<const T>(p_buf.data(), size());
}
void swap(StringBase &v) {

10
octa/vector.h
View File

@ -34,7 +34,7 @@ namespace octa {
void ctor_from_range(R &range, EnableIf<IsFiniteRandomAccessRange<R>
::value, bool
> = true) {
RangeSize<R> len = range.length();
RangeSize<R> len = range.size();
reserve(len);
p_len = len;
for (size_t i = 0; !range.empty(); range.pop_first()) {
@ -88,7 +88,7 @@ namespace octa {
}
Vector(InitializerList<T> v): Vector() {
size_t len = v.length();
size_t len = v.size();
const T *ptr = v.data();
reserve(len);
for (size_t i = 0; i < len; ++i)
@ -143,7 +143,7 @@ namespace octa {
Vector<T> &operator=(InitializerList<T> il) {
clear();
size_t ilen = il.length();
size_t ilen = il.size();
reserve(ilen);
if (octa::IsPod<T>()) {
memcpy(p_buf, il.data(), ilen);
@ -245,7 +245,7 @@ namespace octa {
T *data() { return p_buf; }
const T *data() const { return p_buf; }
size_t length() const { return p_len; }
size_t size() const { return p_len; }
size_t capacity() const { return p_cap; }
bool empty() const { return (p_len == 0); }
@ -285,7 +285,7 @@ namespace octa {
template<typename U>
T *insert_range(size_t idx, U range) {
size_t len = range.length();
size_t len = range.size();
insert_base(idx, len);
for (size_t i = 0; i < len; ++i) {
p_buf[idx + i] = range.first();