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

const syntax refactoring

master
Daniel Kolesa 2016-06-23 19:18:35 +01:00
parent 430ca81bfd
commit 7912c24e3a
25 changed files with 801 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/format.cc
View File

@ -12,7 +12,7 @@ struct Foo {
/* implementing formatting for custom objects - external function */ /* implementing formatting for custom objects - external function */
template<typename R> template<typename R>
bool to_format(const Foo &, R &writer, const FormatSpec &fs) { bool to_format(Foo const &, R &writer, FormatSpec const &fs) {
switch (fs.spec()) { switch (fs.spec()) {
case 'i': case 'i':
writer.put_string("Foo1"); writer.put_string("Foo1");
@ -27,7 +27,7 @@ bool to_format(const Foo &, R &writer, const FormatSpec &fs) {
struct Bar { struct Bar {
/* implementing formatting for custom objects - method */ /* implementing formatting for custom objects - method */
template<typename R> template<typename R>
bool to_format(R &writer, const FormatSpec &fs) const { bool to_format(R &writer, FormatSpec const &fs) const {
switch (fs.spec()) { switch (fs.spec()) {
case 'i': case 'i':
writer.put_string("Bar1"); writer.put_string("Bar1");
@ -64,7 +64,7 @@ int main() {
writefln("{ %-#(%s: %d, %) }", m); writefln("{ %-#(%s: %d, %) }", m);
/* tuple format test */ /* tuple format test */
Tuple<int, float, const char *> xt[] = { Tuple<int, float, char const *> xt[] = {
make_tuple(5, 3.14f, "foo"), make_tuple(5, 3.14f, "foo"),
make_tuple(3, 1.23f, "bar"), make_tuple(3, 1.23f, "bar"),
make_tuple(9, 8.66f, "baz") make_tuple(9, 8.66f, "baz")

6
examples/signal.cc
View File

@ -9,8 +9,8 @@ struct SignalTest {
* can actually emit (in that case, the reference passed to each * can actually emit (in that case, the reference passed to each
* callback will always be const to make sure nothing changes) * callback will always be const to make sure nothing changes)
*/ */
Signal<const SignalTest, int, ConstCharRange> on_simple = this; Signal<SignalTest const, int, ConstCharRange> on_simple = this;
Signal< SignalTest, float > on_param = this; Signal<SignalTest , float > on_param = this;
SignalTest(): p_param(3.14f) { SignalTest(): p_param(3.14f) {
/* we can connect methods */ /* we can connect methods */
@ -48,7 +48,7 @@ int main() {
/* we can connect lambdas, including closures /* we can connect lambdas, including closures
* this callback can access "test" easily and it will still work * this callback can access "test" easily and it will still work
*/ */
auto idx = st.on_simple.connect([&](const SignalTest &, int v, auto idx = st.on_simple.connect([&](SignalTest const &, int v,
ConstCharRange str) { ConstCharRange str) {
writefln("and lambda test: %d, %s (%d)", v, str, test); writefln("and lambda test: %d, %s (%d)", v, str, test);
}); });

42
ostd/algorithm.hh
View File

@ -156,20 +156,20 @@ inline auto sort() {
/* min/max(_element) */ /* min/max(_element) */
template<typename T> template<typename T>
inline const T &min(const T &a, const T &b) { inline T const &min(T const &a, T const &b) {
return (a < b) ? a : b; return (a < b) ? a : b;
} }
template<typename T, typename C> template<typename T, typename C>
inline const T &min_cmp(const T &a, const T &b, C compare) { inline T const &min_cmp(T const &a, T const &b, C compare) {
return compare(a, b) ? a : b; return compare(a, b) ? a : b;
} }
template<typename T> template<typename T>
inline const T &max(const T &a, const T &b) { inline T const &max(T const &a, T const &b) {
return (a < b) ? b : a; return (a < b) ? b : a;
} }
template<typename T, typename C> template<typename T, typename C>
inline const T &max_cmp(const T &a, const T &b, C compare) { inline T const &max_cmp(T const &a, T const &b, C compare) {
return compare(a, b) ? b : a; return compare(a, b) ? b : a;
} }
@ -247,12 +247,12 @@ inline T max_cmp(std::initializer_list<T> il, C compare) {
/* clamp */ /* clamp */
template<typename T, typename U> template<typename T, typename U>
inline T clamp(const T &v, const U &lo, const U &hi) { inline T clamp(T const &v, U const &lo, U const &hi) {
return ostd::max(T(lo), ostd::min(v, T(hi))); return ostd::max(T(lo), ostd::min(v, T(hi)));
} }
template<typename T, typename U, typename C> template<typename T, typename U, typename C>
inline T clamp(const T &v, const U &lo, const U &hi, C compare) { inline T clamp(T const &v, U const &lo, U const &hi, C compare) {
return ostd::max_cmp(T(lo), ostd::min_cmp(v, T(hi), compare), compare); return ostd::max_cmp(T(lo), ostd::min_cmp(v, T(hi), compare), compare);
} }
@ -352,7 +352,7 @@ inline auto none_of(F &&func) {
} }
template<typename R, typename T> template<typename R, typename T>
inline R find(R range, const T &v) { inline R find(R range, T const &v) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
if (range.front() == v) if (range.front() == v)
break; break;
@ -367,7 +367,7 @@ inline auto find(T &&v) {
} }
template<typename R, typename T> template<typename R, typename T>
inline R find_last(R range, const T &v) { inline R find_last(R range, T const &v) {
range = find(range, v); range = find(range, v);
if (!range.empty()) for (;;) { if (!range.empty()) for (;;) {
R prev = range; R prev = range;
@ -449,7 +449,7 @@ inline auto find_one_of(R &&values) {
} }
template<typename R, typename T> template<typename R, typename T>
inline RangeSize<R> count(R range, const T &v) { inline RangeSize<R> count(R range, T const &v) {
RangeSize<R> ret = 0; RangeSize<R> ret = 0;
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
if (range.front() == v) if (range.front() == v)
@ -574,7 +574,7 @@ inline R2 reverse_copy(R1 irange, R2 orange) {
} }
template<typename R, typename T> template<typename R, typename T>
inline void fill(R range, const T &v) { inline void fill(R range, T const &v) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
range.front() = v; range.front() = v;
} }
@ -666,14 +666,14 @@ private:
public: public:
MapRange() = delete; MapRange() = delete;
template<typename FF> template<typename FF>
MapRange(const T &range, FF &&func): MapRange(T const &range, FF &&func):
p_range(range), p_func(forward<FF>(func)) {} p_range(range), p_func(forward<FF>(func)) {}
MapRange(const MapRange &it): MapRange(MapRange const &it):
p_range(it.p_range), p_func(it.p_func) {} p_range(it.p_range), p_func(it.p_func) {}
MapRange(MapRange &&it): MapRange(MapRange &&it):
p_range(move(it.p_range)), p_func(move(it.p_func)) {} p_range(move(it.p_range)), p_func(move(it.p_func)) {}
MapRange &operator=(const MapRange &v) { MapRange &operator=(MapRange const &v) {
p_range = v.p_range; p_range = v.p_range;
p_func = v.p_func; p_func = v.p_func;
return *this; return *this;
@ -687,17 +687,17 @@ public:
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_front(const MapRange &r) const { bool equals_front(MapRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
bool equals_back(const MapRange &r) const { bool equals_back(MapRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
RangeDifference<T> distance_front(const MapRange &r) const { RangeDifference<T> distance_front(MapRange const &r) const {
return p_range.distance_front(r.p_range); return p_range.distance_front(r.p_range);
} }
RangeDifference<T> distance_back(const MapRange &r) const { RangeDifference<T> distance_back(MapRange const &r) const {
return p_range.distance_back(r.p_range); return p_range.distance_back(r.p_range);
} }
@ -766,11 +766,11 @@ private:
public: public:
FilterRange() = delete; FilterRange() = delete;
template<typename P> template<typename P>
FilterRange(const T &range, P &&pred): p_range(range), FilterRange(T const &range, P &&pred): p_range(range),
p_pred(forward<P>(pred)) { p_pred(forward<P>(pred)) {
advance_valid(); advance_valid();
} }
FilterRange(const FilterRange &it): p_range(it.p_range), FilterRange(FilterRange const &it): p_range(it.p_range),
p_pred(it.p_pred) { p_pred(it.p_pred) {
advance_valid(); advance_valid();
} }
@ -779,7 +779,7 @@ public:
advance_valid(); advance_valid();
} }
FilterRange &operator=(const FilterRange &v) { FilterRange &operator=(FilterRange const &v) {
p_range = v.p_range; p_range = v.p_range;
p_pred = v.p_pred; p_pred = v.p_pred;
advance_valid(); advance_valid();
@ -794,7 +794,7 @@ public:
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_front(const FilterRange &r) const { bool equals_front(FilterRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }

30
ostd/array.hh
View File

@ -21,29 +21,29 @@ struct Array {
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Value = T; using Value = T;
using Reference = T &; using Reference = T &;
using ConstReference = const T &; using ConstReference = T const &;
using Pointer = T *; using Pointer = T *;
using ConstPointer = const T *; using ConstPointer = T const *;
using Range = PointerRange<T>; using Range = PointerRange<T>;
using ConstRange = PointerRange<const T>; using ConstRange = PointerRange<T const>;
T &operator[](Size i) { return p_buf[i]; } T &operator[](Size i) { return p_buf[i]; }
const T &operator[](Size i) const { return p_buf[i]; } T const &operator[](Size i) const { return p_buf[i]; }
T *at(Size i) { T *at(Size i) {
if (!in_range(i)) return nullptr; if (!in_range(i)) return nullptr;
return &p_buf[i]; return &p_buf[i];
} }
const T *at(Size i) const { T const *at(Size i) const {
if (!in_range(i)) return nullptr; if (!in_range(i)) return nullptr;
return &p_buf[i]; return &p_buf[i];
} }
T &front() { return p_buf[0]; } T &front() { return p_buf[0]; }
const T &front() const { return p_buf[0]; } T const &front() const { return p_buf[0]; }
T &back() { 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]; } T const &back() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
Size size() const { return N; } Size size() const { return N; }
Size max_size() const { return Size(~0) / sizeof(T); } Size max_size() const { return Size(~0) / sizeof(T); }
@ -90,7 +90,7 @@ inline TupleElement<I, Array<T, N>> &get(Array<T, N> &a) {
} }
template<Size I, typename T, Size N> template<Size I, typename T, Size N>
inline const TupleElement<I, Array<T, N>> &get(const Array<T, N> &a) { inline TupleElement<I, Array<T, N>> const &get(Array<T, N> const &a) {
return a[I]; return a[I];
} }
@ -100,37 +100,37 @@ inline TupleElement<I, Array<T, N>> &&get(Array<T, N> &&a) {
} }
template<Size I, typename T, Size N> template<Size I, typename T, Size N>
inline const TupleElement<I, Array<T, N>> &&get(const Array<T, N> &&a) { inline TupleElement<I, Array<T, N>> const &&get(Array<T, N> const &&a) {
return move(a.p_buf[I]); return move(a.p_buf[I]);
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator==(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator==(Array<T, N> const &x, Array<T, N> const &y) {
return equal(x.iter(), y.iter()); return equal(x.iter(), y.iter());
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator!=(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator!=(Array<T, N> const &x, Array<T, N> const &y) {
return !(x == y); return !(x == y);
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator<(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator<(Array<T, N> const &x, Array<T, N> const &y) {
return lexicographical_compare(x.iter(), y.iter()); return lexicographical_compare(x.iter(), y.iter());
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator>(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator>(Array<T, N> const &x, Array<T, N> const &y) {
return (y < x); return (y < x);
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator<=(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator<=(Array<T, N> const &x, Array<T, N> const &y) {
return !(y < x); return !(y < x);
} }
template<typename T, Size N> template<typename T, Size N>
inline bool operator>=(const Array<T, N> &x, const Array<T, N> &y) { inline bool operator>=(Array<T, N> const &x, Array<T, N> const &y) {
return !(x < y); return !(x < y);
} }

151
ostd/atomic.hh
View File

@ -46,18 +46,18 @@ namespace detail {
template<typename T> template<typename T>
static inline EnableIf< static inline EnableIf<
CanAtomicAssign<volatile AtomicBase<T> *, T> CanAtomicAssign<AtomicBase<T> volatile *, T>
> atomic_init(volatile AtomicBase<T> *a, T v) { > atomic_init(AtomicBase<T> volatile *a, T v) {
a->p_value = v; a->p_value = v;
} }
template<typename T> template<typename T>
static inline EnableIf< static inline EnableIf<
!CanAtomicAssign<volatile AtomicBase<T> *, T> && !CanAtomicAssign<AtomicBase<T> volatile *, T> &&
CanAtomicAssign< AtomicBase<T> *, T> CanAtomicAssign<AtomicBase<T> *, T>
> atomic_init(volatile AtomicBase<T> *a, T v) { > atomic_init(AtomicBase<T> volatile *a, T v) {
volatile char *to = (volatile char *)(&a->p_value); char volatile *to = (char volatile *)(&a->p_value);
volatile char *end = to + sizeof(T); char volatile *end = to + sizeof(T);
char *from = (char *)(&v); char *from = (char *)(&v);
while (to != end) *to++ =*from++; while (to != end) *to++ =*from++;
} }
@ -119,44 +119,40 @@ namespace detail {
} }
template<typename T> template<typename T>
static inline void atomic_store(volatile AtomicBase<T> *a, static inline void atomic_store(AtomicBase<T> volatile *a,
T v, MemoryOrder ord) { T v, MemoryOrder ord) {
__atomic_store(&a->p_value, &v, to_gcc_order(ord)); __atomic_store(&a->p_value, &v, to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline void atomic_store(AtomicBase<T> *a, static inline void atomic_store(AtomicBase<T> *a,T v, MemoryOrder ord) {
T v, MemoryOrder ord) {
__atomic_store(&a->p_value, &v, to_gcc_order(ord)); __atomic_store(&a->p_value, &v, to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_load(volatile AtomicBase<T> *a, static inline T atomic_load(AtomicBase<T> volatile *a, MemoryOrder ord) {
MemoryOrder ord) {
T r; T r;
__atomic_load(&a->p_value, &r, to_gcc_order(ord)); __atomic_load(&a->p_value, &r, to_gcc_order(ord));
return r; return r;
} }
template<typename T> template<typename T>
static inline T atomic_load(AtomicBase<T> *a, static inline T atomic_load(AtomicBase<T> *a, MemoryOrder ord) {
MemoryOrder ord) {
T r; T r;
__atomic_load(&a->p_value, &r, to_gcc_order(ord)); __atomic_load(&a->p_value, &r, to_gcc_order(ord));
return r; return r;
} }
template<typename T> template<typename T>
static inline T atomic_exchange(volatile AtomicBase<T> *a, static inline T atomic_exchange(AtomicBase<T> volatile *a,
T v, MemoryOrder ord) { T v, MemoryOrder ord) {
T r; T r;
__atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord)); __atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord));
return r; return r;
} }
template<typename T> template<typename T>
static inline T atomic_exchange(AtomicBase<T> *a, static inline T atomic_exchange(AtomicBase<T> *a, T v, MemoryOrder ord) {
T v, MemoryOrder ord) {
T r; T r;
__atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord)); __atomic_exchange(&a->p_value, &v, &r, to_gcc_order(ord));
return r; return r;
@ -164,7 +160,7 @@ namespace detail {
template<typename T> template<typename T>
static inline bool atomic_compare_exchange_strong( static inline bool atomic_compare_exchange_strong(
volatile AtomicBase<T> *a, T *expected, T v, AtomicBase<T> volatile *a, T *expected, T v,
MemoryOrder success, MemoryOrder failure MemoryOrder success, MemoryOrder failure
) { ) {
return __atomic_compare_exchange(&a->p_value, expected, &v, false, return __atomic_compare_exchange(&a->p_value, expected, &v, false,
@ -182,7 +178,7 @@ namespace detail {
template<typename T> template<typename T>
static inline bool atomic_compare_exchange_weak( static inline bool atomic_compare_exchange_weak(
volatile AtomicBase<T> *a, T *expected, T v, AtomicBase<T> volatile *a, T *expected, T v,
MemoryOrder success, MemoryOrder failure MemoryOrder success, MemoryOrder failure
) { ) {
return __atomic_compare_exchange(&a->p_value, expected, &v, true, return __atomic_compare_exchange(&a->p_value, expected, &v, true,
@ -208,71 +204,71 @@ namespace detail {
template<typename T, Size N> struct SkipAmt<T[N]> {}; template<typename T, Size N> struct SkipAmt<T[N]> {};
template<typename T, typename U> template<typename T, typename U>
static inline T atomic_fetch_add(volatile AtomicBase<T> *a, static inline T atomic_fetch_add(AtomicBase<T> volatile *a,
U d, MemoryOrder ord) { U d, MemoryOrder ord) {
return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value, return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T, typename U> template<typename T, typename U>
static inline T atomic_fetch_add(AtomicBase<T> *a, static inline T atomic_fetch_add(AtomicBase<T> *a,
U d, MemoryOrder ord) { U d, MemoryOrder ord) {
return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value, return __atomic_fetch_add(&a->p_value, d * SkipAmt<T>::value,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T, typename U> template<typename T, typename U>
static inline T atomic_fetch_sub(volatile AtomicBase<T> *a, static inline T atomic_fetch_sub(AtomicBase<T> volatile *a,
U d, MemoryOrder ord) { U d, MemoryOrder ord) {
return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value, return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T, typename U> template<typename T, typename U>
static inline T atomic_fetch_sub(AtomicBase<T> *a, static inline T atomic_fetch_sub(AtomicBase<T> *a,
U d, MemoryOrder ord) { U d, MemoryOrder ord) {
return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value, return __atomic_fetch_sub(&a->p_value, d * SkipAmt<T>::value,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_and(volatile AtomicBase<T> *a, static inline T atomic_fetch_and(AtomicBase<T> volatile *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_and(&a->p_value, pattern, return __atomic_fetch_and(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_and(AtomicBase<T> *a, static inline T atomic_fetch_and(AtomicBase<T> *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_and(&a->p_value, pattern, return __atomic_fetch_and(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_or(volatile AtomicBase<T> *a, static inline T atomic_fetch_or(AtomicBase<T> volatile *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_or(&a->p_value, pattern, return __atomic_fetch_or(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_or(AtomicBase<T> *a, static inline T atomic_fetch_or(AtomicBase<T> *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_or(&a->p_value, pattern, return __atomic_fetch_or(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_xor(volatile AtomicBase<T> *a, static inline T atomic_fetch_xor(AtomicBase<T> volatile *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_xor(&a->p_value, pattern, return __atomic_fetch_xor(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
template<typename T> template<typename T>
static inline T atomic_fetch_xor(AtomicBase<T> *a, static inline T atomic_fetch_xor(AtomicBase<T> *a,
T pattern, MemoryOrder ord) { T pattern, MemoryOrder ord) {
return __atomic_fetch_xor(&a->p_value, pattern, return __atomic_fetch_xor(&a->p_value, pattern,
to_gcc_order(ord)); to_gcc_order(ord));
} }
@ -294,10 +290,10 @@ namespace detail {
constexpr Atomic(T v): p_a(v) {} constexpr Atomic(T v): p_a(v) {}
Atomic(const Atomic &) = delete; Atomic(Atomic const &) = delete;
Atomic &operator=(const Atomic &) = delete; Atomic &operator=(Atomic const &) = delete;
Atomic &operator=(const Atomic &) volatile = delete; Atomic &operator=(Atomic const &) volatile = delete;
bool is_lock_free() const volatile { bool is_lock_free() const volatile {
return atomic_is_lock_free(sizeof(T)); return atomic_is_lock_free(sizeof(T));
@ -515,17 +511,17 @@ struct Atomic<T *>: detail::Atomic<T *> {
}; };
template<typename T> template<typename T>
inline bool atomic_is_lock_free(const volatile Atomic<T> *a) { inline bool atomic_is_lock_free(Atomic<T> const volatile *a) {
return a->is_lock_free(); return a->is_lock_free();
} }
template<typename T> template<typename T>
inline bool atomic_is_lock_free(const Atomic<T> *a) { inline bool atomic_is_lock_free(Atomic<T> const *a) {
return a->is_lock_free(); return a->is_lock_free();
} }
template<typename T> template<typename T>
inline void atomic_init(volatile Atomic<T> *a, T v) { inline void atomic_init(Atomic<T> volatile *a, T v) {
detail::atomic_init(&a->p_a, v); detail::atomic_init(&a->p_a, v);
} }
@ -535,7 +531,7 @@ inline void atomic_init(Atomic<T> *a, T v) {
} }
template <typename T> template <typename T>
inline void atomic_store(volatile Atomic<T> *a, T v) { inline void atomic_store(Atomic<T> volatile *a, T v) {
a->store(v); a->store(v);
} }
@ -545,40 +541,37 @@ inline void atomic_store(Atomic<T> *a, T v) {
} }
template <typename T> template <typename T>
inline void atomic_store_explicit(volatile Atomic<T> *a, T v, inline void atomic_store_explicit(Atomic<T> volatile *a, T v, MemoryOrder ord) {
MemoryOrder ord) {
a->store(v, ord); a->store(v, ord);
} }
template <typename T> template <typename T>
inline void atomic_store_explicit(Atomic<T> *a, T v, inline void atomic_store_explicit(Atomic<T> *a, T v, MemoryOrder ord) {
MemoryOrder ord) {
a->store(v, ord); a->store(v, ord);
} }
template <typename T> template <typename T>
inline T atomic_load(const volatile Atomic<T> *a) { inline T atomic_load(Atomic<T> const volatile *a) {
return a->load(); return a->load();
} }
template <typename T> template <typename T>
inline T atomic_load(const Atomic<T> *a) { inline T atomic_load(Atomic<T> const *a) {
return a->load(); return a->load();
} }
template <typename T> template <typename T>
inline T atomic_load_explicit(const volatile Atomic<T> *a, inline T atomic_load_explicit(Atomic<T> const volatile *a, MemoryOrder ord) {
MemoryOrder ord) {
return a->load(ord); return a->load(ord);
} }
template <typename T> template <typename T>
inline T atomic_load_explicit(const Atomic<T> *a, MemoryOrder ord) { inline T atomic_load_explicit(Atomic<T> const *a, MemoryOrder ord) {
return a->load(ord); return a->load(ord);
} }
template <typename T> template <typename T>
inline T atomic_exchange(volatile Atomic<T> *a, T v) { inline T atomic_exchange(Atomic<T> volatile *a, T v) {
return a->exchange(v); return a->exchange(v);
} }
@ -588,7 +581,7 @@ inline T atomic_exchange(Atomic<T> *a, T v) {
} }
template <typename T> template <typename T>
inline T atomic_exchange_explicit(volatile Atomic<T> *a, T v, inline T atomic_exchange_explicit(Atomic<T> volatile *a, T v,
MemoryOrder ord) { MemoryOrder ord) {
return a->exchange(v, ord); return a->exchange(v, ord);
} }
@ -600,7 +593,7 @@ inline T atomic_exchange_explicit(Atomic<T> *a, T v,
} }
template <typename T> template <typename T>
inline bool atomic_compare_exchange_weak(volatile Atomic<T> *a, inline bool atomic_compare_exchange_weak(Atomic<T> volatile *a,
T *e, T v) { T *e, T v) {
return a->compare_exchange_weak(*e, v); return a->compare_exchange_weak(*e, v);
} }
@ -611,7 +604,7 @@ inline bool atomic_compare_exchange_weak(Atomic<T> *a, T *e, T v) {
} }
template <typename T> template <typename T>
inline bool atomic_compare_exchange_strong(volatile Atomic<T> *a, inline bool atomic_compare_exchange_strong(Atomic<T> volatile *a,
T *e, T v) { T *e, T v) {
return a->compare_exchange_strong(*e, v); return a->compare_exchange_strong(*e, v);
} }
@ -622,7 +615,7 @@ inline bool atomic_compare_exchange_strong(Atomic<T> *a, T *e, T v) {
} }
template <typename T> template <typename T>
inline bool atomic_compare_exchange_weak_explicit(volatile Atomic<T> *a, inline bool atomic_compare_exchange_weak_explicit(Atomic<T> volatile *a,
T *e, T v, T *e, T v,
MemoryOrder s, MemoryOrder s,
MemoryOrder f) { MemoryOrder f) {
@ -638,7 +631,7 @@ inline bool atomic_compare_exchange_weak_explicit(Atomic<T> *a, T *e,
} }
template <typename T> template <typename T>
inline bool atomic_compare_exchange_strong_explicit(volatile Atomic<T> *a, inline bool atomic_compare_exchange_strong_explicit(Atomic<T> volatile *a,
T *e, T v, T *e, T v,
MemoryOrder s, MemoryOrder s,
MemoryOrder f) { MemoryOrder f) {
@ -655,7 +648,7 @@ inline bool atomic_compare_exchange_strong_explicit(Atomic<T> *a, T *e,
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_add(volatile Atomic<T> *a, T op) { atomic_fetch_add(Atomic<T> volatile *a, T op) {
return a->fetch_add(op); return a->fetch_add(op);
} }
@ -666,7 +659,7 @@ atomic_fetch_add(Atomic<T> *a, T op) {
} }
template <typename T> template <typename T>
inline T *atomic_fetch_add(volatile Atomic<T *> *a, Ptrdiff op) { inline T *atomic_fetch_add(Atomic<T *> volatile *a, Ptrdiff op) {
return a->fetch_add(op); return a->fetch_add(op);
} }
@ -677,7 +670,7 @@ inline T *atomic_fetch_add(Atomic<T *> *a, Ptrdiff op) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_add_explicit(volatile Atomic<T> *a, T op, atomic_fetch_add_explicit(Atomic<T> volatile *a, T op,
MemoryOrder ord) { MemoryOrder ord) {
return a->fetch_add(op, ord); return a->fetch_add(op, ord);
} }
@ -689,7 +682,7 @@ atomic_fetch_add_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
} }
template <typename T> template <typename T>
inline T *atomic_fetch_add_explicit(volatile Atomic<T *> *a, inline T *atomic_fetch_add_explicit(Atomic<T *> volatile *a,
Ptrdiff op, MemoryOrder ord) { Ptrdiff op, MemoryOrder ord) {
return a->fetch_add(op, ord); return a->fetch_add(op, ord);
} }
@ -702,7 +695,7 @@ inline T *atomic_fetch_add_explicit(Atomic<T *> *a, Ptrdiff op,
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_sub(volatile Atomic<T> *a, T op) { atomic_fetch_sub(Atomic<T> volatile *a, T op) {
return a->fetch_sub(op); return a->fetch_sub(op);
} }
@ -713,7 +706,7 @@ atomic_fetch_sub(Atomic<T> *a, T op) {
} }
template <typename T> template <typename T>
inline T *atomic_fetch_sub(volatile Atomic<T *> *a, Ptrdiff op) { inline T *atomic_fetch_sub(Atomic<T *> volatile *a, Ptrdiff op) {
return a->fetch_sub(op); return a->fetch_sub(op);
} }
@ -724,7 +717,7 @@ inline T *atomic_fetch_sub(Atomic<T *> *a, Ptrdiff op) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_sub_explicit(volatile Atomic<T> *a, T op, atomic_fetch_sub_explicit(Atomic<T> volatile *a, T op,
MemoryOrder ord) { MemoryOrder ord) {
return a->fetch_sub(op, ord); return a->fetch_sub(op, ord);
} }
@ -736,7 +729,7 @@ atomic_fetch_sub_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
} }
template <typename T> template <typename T>
inline T *atomic_fetch_sub_explicit(volatile Atomic<T *> *a, inline T *atomic_fetch_sub_explicit(Atomic<T *> volatile *a,
Ptrdiff op, MemoryOrder ord) { Ptrdiff op, MemoryOrder ord) {
return a->fetch_sub(op, ord); return a->fetch_sub(op, ord);
} }
@ -749,7 +742,7 @@ inline T *atomic_fetch_sub_explicit(Atomic<T *> *a, Ptrdiff op,
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_and(volatile Atomic<T> *a, T op) { atomic_fetch_and(Atomic<T> volatile *a, T op) {
return a->fetch_and(op); return a->fetch_and(op);
} }
@ -761,7 +754,7 @@ atomic_fetch_and(Atomic<T> *a, T op) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_and_explicit(volatile Atomic<T> *a, T op, atomic_fetch_and_explicit(Atomic<T> volatile *a, T op,
MemoryOrder ord) { MemoryOrder ord) {
return a->fetch_and(op, ord); return a->fetch_and(op, ord);
} }
@ -774,7 +767,7 @@ atomic_fetch_and_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_or(volatile Atomic<T> *a, T op) { atomic_fetch_or(Atomic<T> volatile *a, T op) {
return a->fetch_or(op); return a->fetch_or(op);
} }
@ -786,7 +779,7 @@ atomic_fetch_or(Atomic<T> *a, T op) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_or_explicit(volatile Atomic<T> *a, T op, atomic_fetch_or_explicit(Atomic<T> volatile *a, T op,
MemoryOrder ord) { MemoryOrder ord) {
return a->fetch_or(op, ord); return a->fetch_or(op, ord);
} }
@ -799,7 +792,7 @@ atomic_fetch_or_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_xor(volatile Atomic<T> *a, T op) { atomic_fetch_xor(Atomic<T> volatile *a, T op) {
return a->fetch_xor(op); return a->fetch_xor(op);
} }
@ -811,7 +804,7 @@ atomic_fetch_xor(Atomic<T> *a, T op) {
template <typename T> template <typename T>
inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T> inline EnableIf<IsIntegral<T> && !IsSame<T, bool>, T>
atomic_fetch_xor_explicit(volatile Atomic<T> *a, T op, atomic_fetch_xor_explicit(Atomic<T> volatile *a, T op,
MemoryOrder ord) { MemoryOrder ord) {
return a->fetch_xor(op, ord); return a->fetch_xor(op, ord);
} }
@ -829,10 +822,10 @@ struct AtomicFlag {
AtomicFlag(bool b): p_a(b) {} AtomicFlag(bool b): p_a(b) {}
AtomicFlag(const AtomicFlag &) = delete; AtomicFlag(AtomicFlag const &) = delete;
AtomicFlag &operator=(const AtomicFlag &) = delete; AtomicFlag &operator=(AtomicFlag const &) = delete;
AtomicFlag &operator=(const AtomicFlag &) volatile = delete; AtomicFlag &operator=(AtomicFlag const &) volatile = delete;
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) volatile { bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return detail::atomic_exchange(&p_a, true, ord); return detail::atomic_exchange(&p_a, true, ord);
@ -851,7 +844,7 @@ struct AtomicFlag {
} }
}; };
inline bool atomic_flag_test_and_set(volatile AtomicFlag *a) { inline bool atomic_flag_test_and_set(AtomicFlag volatile *a) {
return a->test_and_set(); return a->test_and_set();
} }
@ -859,7 +852,7 @@ inline bool atomic_flag_test_and_set(AtomicFlag *a) {
return a->test_and_set(); return a->test_and_set();
} }
inline bool atomic_flag_test_and_set_explicit(volatile AtomicFlag *a, inline bool atomic_flag_test_and_set_explicit(AtomicFlag volatile *a,
MemoryOrder ord) { MemoryOrder ord) {
return a->test_and_set(ord); return a->test_and_set(ord);
} }
@ -869,7 +862,7 @@ inline bool atomic_flag_test_and_set_explicit(AtomicFlag *a,
return a->test_and_set(ord); return a->test_and_set(ord);
} }
inline void atomic_flag_clear(volatile AtomicFlag *a) { inline void atomic_flag_clear(AtomicFlag volatile *a) {
a->clear(); a->clear();
} }
@ -877,7 +870,7 @@ inline void atomic_flag_clear(AtomicFlag *a) {
a->clear(); a->clear();
} }
inline void atomic_flag_clear_explicit(volatile AtomicFlag *a, inline void atomic_flag_clear_explicit(AtomicFlag volatile *a,
MemoryOrder ord) { MemoryOrder ord) {
a->clear(ord); a->clear(ord);
} }

2
ostd/environ.hh
View File

@ -17,7 +17,7 @@ namespace environ {
inline Maybe<ConstCharRange> get(ConstCharRange name) { inline Maybe<ConstCharRange> get(ConstCharRange name) {
char buf[256]; char buf[256];
const char *ret = getenv(to_temp_cstr(name, buf, sizeof(buf)).get()); char const *ret = getenv(to_temp_cstr(name, buf, sizeof(buf)).get());
if (!ret) return ostd::nothing; if (!ret) return ostd::nothing;
return ostd::move(ConstCharRange(ret)); return ostd::move(ConstCharRange(ret));
} }

18
ostd/event.hh
View File

@ -16,8 +16,8 @@ namespace detail {
struct SignalBase { struct SignalBase {
SignalBase(C *cl): p_class(cl), p_funcs(nullptr), p_nfuncs(0) {} SignalBase(C *cl): p_class(cl), p_funcs(nullptr), p_nfuncs(0) {}
SignalBase(const SignalBase &ev): p_class(ev.p_class), SignalBase(SignalBase const &ev): p_class(ev.p_class),
p_nfuncs(ev.p_nfuncs) { p_nfuncs(ev.p_nfuncs) {
using Func = Function<void(C &, A...)>; using Func = Function<void(C &, A...)>;
Func *nbuf = (Func *)new byte[sizeof(Func) * p_nfuncs]; Func *nbuf = (Func *)new byte[sizeof(Func) * p_nfuncs];
for (Size i = 0; i < p_nfuncs; ++i) for (Size i = 0; i < p_nfuncs; ++i)
@ -30,7 +30,7 @@ namespace detail {
swap(ev); swap(ev);
} }
SignalBase &operator=(const SignalBase &ev) { SignalBase &operator=(SignalBase const &ev) {
using Func = Function<void(C &, A...)>; using Func = Function<void(C &, A...)>;
p_class = ev.p_class; p_class = ev.p_class;
p_nfuncs = ev.p_nfuncs; p_nfuncs = ev.p_nfuncs;
@ -118,10 +118,10 @@ private:
Base p_base; Base p_base;
public: public:
Signal(C *cl): p_base(cl) {} Signal(C *cl): p_base(cl) {}
Signal(const Signal &ev): p_base(ev.p_base) {} Signal(Signal const &ev): p_base(ev.p_base) {}
Signal(Signal &&ev): p_base(move(ev.p_base)) {} Signal(Signal &&ev): p_base(move(ev.p_base)) {}
Signal &operator=(const Signal &ev) { Signal &operator=(Signal const &ev) {
p_base = ev.p_base; p_base = ev.p_base;
return *this; return *this;
} }
@ -151,16 +151,16 @@ public:
}; };
template<typename C, typename ...A> template<typename C, typename ...A>
struct Signal<const C, A...> { struct Signal<C const, A...> {
private: private:
using Base = detail::SignalBase<const C, A...>; using Base = detail::SignalBase<C const, A...>;
Base p_base; Base p_base;
public: public:
Signal(C *cl): p_base(cl) {} Signal(C *cl): p_base(cl) {}
Signal(const Signal &ev): p_base(ev.p_base) {} Signal(Signal const &ev): p_base(ev.p_base) {}
Signal(Signal &&ev): p_base(move(ev.p_base)) {} Signal(Signal &&ev): p_base(move(ev.p_base)) {}
Signal &operator=(const Signal &ev) { Signal &operator=(Signal const &ev) {
p_base = ev.p_base; p_base = ev.p_base;
return *this; return *this;
} }

30
ostd/filesystem.hh
View File

@ -38,7 +38,7 @@ static constexpr char PathSeparator = '/';
#ifdef OSTD_PLATFORM_WIN32 #ifdef OSTD_PLATFORM_WIN32
namespace detail { namespace detail {
inline time_t filetime_to_time_t(const FILETIME &ft) { inline time_t filetime_to_time_t(FILETIME const &ft) {
ULARGE_INTEGER ul; ULARGE_INTEGER ul;
ul.LowPart = ft.dwLowDateTime; ul.LowPart = ft.dwLowDateTime;
ul.HighPart = ft.dwHighDateTime; ul.HighPart = ft.dwHighDateTime;
@ -54,7 +54,7 @@ inline void path_normalize(CharRange) {
struct FileInfo { struct FileInfo {
FileInfo() {} FileInfo() {}
FileInfo(const FileInfo &i): FileInfo(FileInfo const &i):
p_slash(i.p_slash), p_dot(i.p_dot), p_type(i.p_type), p_slash(i.p_slash), p_dot(i.p_dot), p_type(i.p_type),
p_path(i.p_path), p_atime(i.p_atime), p_mtime(i.p_mtime), p_path(i.p_path), p_atime(i.p_atime), p_mtime(i.p_mtime),
p_ctime(i.p_ctime) {} p_ctime(i.p_ctime) {}
@ -72,7 +72,7 @@ struct FileInfo {
init_from_str(path); init_from_str(path);
} }
FileInfo &operator=(const FileInfo &i) { FileInfo &operator=(FileInfo const &i) {
p_slash = i.p_slash; p_slash = i.p_slash;
p_dot = i.p_dot; p_dot = i.p_dot;
p_type = i.p_type; p_type = i.p_type;
@ -215,7 +215,7 @@ struct DirectoryStream {
friend struct DirectoryRange; friend struct DirectoryRange;
DirectoryStream(): p_d(), p_de(), p_dev(), p_path() {} DirectoryStream(): p_d(), p_de(), p_dev(), p_path() {}
DirectoryStream(const DirectoryStream &) = delete; DirectoryStream(DirectoryStream const &) = delete;
DirectoryStream(DirectoryStream &&s): p_d(s.p_d), p_de(s.p_de), DirectoryStream(DirectoryStream &&s): p_d(s.p_d), p_de(s.p_de),
p_dev(s.p_dev), p_dev(s.p_dev),
p_path(move(s.p_path)) { p_path(move(s.p_path)) {
@ -230,7 +230,7 @@ struct DirectoryStream {
~DirectoryStream() { close(); } ~DirectoryStream() { close(); }
DirectoryStream &operator=(const DirectoryStream &) = delete; DirectoryStream &operator=(DirectoryStream const &) = delete;
DirectoryStream &operator=(DirectoryStream &&s) { DirectoryStream &operator=(DirectoryStream &&s) {
close(); close();
swap(s); swap(s);
@ -325,7 +325,7 @@ private:
return FileInfo(); return FileInfo();
String ap = p_path; String ap = p_path;
ap += PathSeparator; ap += PathSeparator;
ap += (const char *)p_de->d_name; ap += (char const *)p_de->d_name;
return FileInfo(ap); return FileInfo(ap);
} }
@ -341,7 +341,7 @@ struct DirectoryStream {
friend struct DirectoryRange; friend struct DirectoryRange;
DirectoryStream(): p_handle(INVALID_HANDLE_VALUE), p_data(), p_path() {} DirectoryStream(): p_handle(INVALID_HANDLE_VALUE), p_data(), p_path() {}
DirectoryStream(const DirectoryStream &) = delete; DirectoryStream(DirectoryStream const &) = delete;
DirectoryStream(DirectoryStream &&s): p_handle(s.p_handle), DirectoryStream(DirectoryStream &&s): p_handle(s.p_handle),
p_data(s.p_data), p_data(s.p_data),
p_path(move(s.p_path)) { p_path(move(s.p_path)) {
@ -355,7 +355,7 @@ struct DirectoryStream {
~DirectoryStream() { close(); } ~DirectoryStream() { close(); }
DirectoryStream &operator=(const DirectoryStream &) = delete; DirectoryStream &operator=(DirectoryStream const &) = delete;
DirectoryStream &operator=(DirectoryStream &&s) { DirectoryStream &operator=(DirectoryStream &&s) {
close(); close();
swap(s); swap(s);
@ -463,7 +463,7 @@ private:
return FileInfo(); return FileInfo();
String ap = p_path; String ap = p_path;
ap += PathSeparator; ap += PathSeparator;
ap += (const char *)p_data.cFileName; ap += (char const *)p_data.cFileName;
return FileInfo(ap); return FileInfo(ap);
} }
@ -478,9 +478,9 @@ struct DirectoryRange: InputRange<
> { > {
DirectoryRange() = delete; DirectoryRange() = delete;
DirectoryRange(DirectoryStream &s): p_stream(&s) {} DirectoryRange(DirectoryStream &s): p_stream(&s) {}
DirectoryRange(const DirectoryRange &r): p_stream(r.p_stream) {} DirectoryRange(DirectoryRange const &r): p_stream(r.p_stream) {}
DirectoryRange &operator=(const DirectoryRange &r) { DirectoryRange &operator=(DirectoryRange const &r) {
p_stream = r.p_stream; p_stream = r.p_stream;
return *this; return *this;
} }
@ -497,7 +497,7 @@ struct DirectoryRange: InputRange<
return p_stream->front(); return p_stream->front();
} }
bool equals_front(const DirectoryRange &s) const { bool equals_front(DirectoryRange const &s) const {
return p_stream == s.p_stream; return p_stream == s.p_stream;
} }
@ -512,7 +512,7 @@ inline DirectoryRange DirectoryStream::iter() {
namespace detail { namespace detail {
template<Size I> struct PathJoin { template<Size I> struct PathJoin {
template<typename T, typename ...A> template<typename T, typename ...A>
static void join(String &s, const T &a, const A &...b) { static void join(String &s, T const &a, A const &...b) {
s += a; s += a;
s += PathSeparator; s += PathSeparator;
PathJoin<I - 1>::join(s, b...); PathJoin<I - 1>::join(s, b...);
@ -521,14 +521,14 @@ namespace detail {
template<> struct PathJoin<1> { template<> struct PathJoin<1> {
template<typename T> template<typename T>
static void join(String &s, const T &a) { static void join(String &s, T const &a) {
s += a; s += a;
} }
}; };
} }
template<typename ...A> template<typename ...A>
inline FileInfo path_join(const A &...args) { inline FileInfo path_join(A const &...args) {
String path; String path;
detail::PathJoin<sizeof...(A)>::join(path, args...); detail::PathJoin<sizeof...(A)>::join(path, args...);
path_normalize(path.iter()); path_normalize(path.iter());

99
ostd/format.hh
View File

@ -62,7 +62,7 @@ namespace detail {
* 7 .. string * 7 .. string
* 8 .. custom object * 8 .. custom object
*/ */
static constexpr const byte fmt_specs[] = { static constexpr byte const fmt_specs[] = {
/* uppercase spec set */ /* uppercase spec set */
1, 3, 8, 8, /* A B C D */ 1, 3, 8, 8, /* A B C D */
1, 1, 1, 8, /* E F G H */ 1, 1, 1, 8, /* E F G H */
@ -88,11 +88,11 @@ namespace detail {
0, 0, 0, 0, 0 0, 0, 0, 0, 0
}; };
static constexpr const int fmt_bases[] = { static constexpr int const fmt_bases[] = {
0, 0, 0, 2, 8, 10, 16, 0 0, 0, 0, 2, 8, 10, 16, 0
}; };
static constexpr const char fmt_digits[2][16] = { static constexpr char fmt_digits[2][16] = {
{ {
'0', '1', '2', '3', '4', '5', '6', '7', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
@ -103,14 +103,14 @@ namespace detail {
} }
}; };
static constexpr const char *fmt_intpfx[2][4] = { static constexpr char const *fmt_intpfx[2][4] = {
{ "0B", "0", "", "0X" }, { "0B", "0", "", "0X" },
{ "0b", "0", "", "0x" } { "0b", "0", "", "0x" }
}; };
/* retrieve width/precision */ /* retrieve width/precision */
template<typename T> template<typename T>
bool convert_arg_param(const T &val, int &param, EnableIf< bool convert_arg_param(T const &val, int &param, EnableIf<
IsIntegral<T>, bool IsIntegral<T>, bool
> = true) { > = true) {
param = int(val); param = int(val);
@ -118,7 +118,7 @@ namespace detail {
} }
template<typename T> template<typename T>
bool convert_arg_param(const T &, int &, EnableIf< bool convert_arg_param(T const &, int &, EnableIf<
!IsIntegral<T>, bool !IsIntegral<T>, bool
> = true) { > = true) {
assert(false && "invalid argument for width/precision"); assert(false && "invalid argument for width/precision");
@ -126,7 +126,7 @@ namespace detail {
} }
template<typename T> template<typename T>
bool get_arg_param(Size idx, int &param, const T &val) { bool get_arg_param(Size idx, int &param, T const &val) {
if (idx) { if (idx) {
assert(false && "not enough format args"); assert(false && "not enough format args");
return false; return false;
@ -134,8 +134,7 @@ namespace detail {
return convert_arg_param(val, param); return convert_arg_param(val, param);
} }
template<typename T, typename ...A> template<typename T, typename ...A>
bool get_arg_param(Size idx, int &param, const T &val, bool get_arg_param(Size idx, int &param, T const &val, A const &...args) {
const A &...args) {
if (idx) return get_arg_param(idx - 1, param, args...); if (idx) return get_arg_param(idx - 1, param, args...);
return convert_arg_param(val, param); return convert_arg_param(val, param);
} }
@ -204,12 +203,12 @@ struct FormatSpec {
bool arg_precision() const { return p_arg_precision; } bool arg_precision() const { return p_arg_precision; }
template<typename ...A> template<typename ...A>
bool set_width(Size idx, const A &...args) { bool set_width(Size idx, A const &...args) {
return detail::get_arg_param(idx, p_width, args...); return detail::get_arg_param(idx, p_width, args...);
} }
template<typename ...A> template<typename ...A>
bool set_precision(Size idx, const A &...args) { bool set_precision(Size idx, A const &...args) {
return detail::get_arg_param(idx, p_precision, args...); return detail::get_arg_param(idx, p_precision, args...);
} }
@ -399,16 +398,16 @@ protected:
/* for custom container formatting */ /* for custom container formatting */
template<typename T, typename R, typename = EnableIf< template<typename T, typename R, typename = EnableIf<
IsSame<decltype(declval<const T &>() IsSame<decltype(declval<T const &>()
.to_format(declval<R &>(), declval<const FormatSpec &>())), bool .to_format(declval<R &>(), declval<FormatSpec const &>())), bool
> >
>> inline bool to_format(const T &v, R &writer, const FormatSpec &fs) { >> inline bool to_format(T const &v, R &writer, FormatSpec const &fs) {
return v.to_format(writer, fs); return v.to_format(writer, fs);
} }
namespace detail { namespace detail {
template<typename R, typename T> template<typename R, typename T>
inline Ptrdiff write_u(R &writer, const FormatSpec *fl, bool neg, T val) { inline Ptrdiff write_u(R &writer, FormatSpec const *fl, bool neg, T val) {
char buf[20]; char buf[20];
Ptrdiff r = 0; Ptrdiff r = 0;
Size n = 0; Size n = 0;
@ -434,7 +433,7 @@ namespace detail {
bool sign = neg + lsgn + lsp; bool sign = neg + lsgn + lsp;
r += sign; r += sign;
const char *pfx = nullptr; char const *pfx = nullptr;
int pfxlen = 0; int pfxlen = 0;
if (flags & FMT_FLAG_HASH && spec != 'd') { if (flags & FMT_FLAG_HASH && spec != 'd') {
pfx = detail::fmt_intpfx[spec >= 'a'][specn - 3]; pfx = detail::fmt_intpfx[spec >= 'a'][specn - 3];
@ -458,7 +457,7 @@ namespace detail {
template<typename R, typename ...A> template<typename R, typename ...A>
static Ptrdiff format_impl(R &writer, Size &fmtn, bool escape, static Ptrdiff format_impl(R &writer, Size &fmtn, bool escape,
ConstCharRange fmt, const A &...args); ConstCharRange fmt, A const &...args);
template<typename T, typename = RangeOf<T>> template<typename T, typename = RangeOf<T>>
static True test_fmt_range(int); static True test_fmt_range(int);
@ -472,8 +471,8 @@ namespace detail {
struct FmtTupleUnpacker { struct FmtTupleUnpacker {
template<typename R, typename T, typename ...A> template<typename R, typename T, typename ...A>
static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc, static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc,
ConstCharRange fmt, const T &item, ConstCharRange fmt, T const &item,
const A &...args) { A const &...args) {
return FmtTupleUnpacker<I - 1>::unpack(writer, fmtn, esc, fmt, return FmtTupleUnpacker<I - 1>::unpack(writer, fmtn, esc, fmt,
item, get<I - 1>(item), args...); item, get<I - 1>(item), args...);
} }
@ -483,15 +482,15 @@ namespace detail {
struct FmtTupleUnpacker<0> { struct FmtTupleUnpacker<0> {
template<typename R, typename T, typename ...A> template<typename R, typename T, typename ...A>
static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc, static inline Ptrdiff unpack(R &writer, Size &fmtn, bool esc,
ConstCharRange fmt, const T &, ConstCharRange fmt, T const &,
const A &...args) { A const &...args) {
return format_impl(writer, fmtn, esc, fmt, args...); return format_impl(writer, fmtn, esc, fmt, args...);
} }
}; };
template<typename R, typename T> template<typename R, typename T>
inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc, bool, inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc, bool,
ConstCharRange fmt, const T &item, ConstCharRange fmt, T const &item,
EnableIf<!IsTupleLike<T>, bool> EnableIf<!IsTupleLike<T>, bool>
= true) { = true) {
return format_impl(writer, fmtn, esc, fmt, item); return format_impl(writer, fmtn, esc, fmt, item);
@ -500,7 +499,7 @@ namespace detail {
template<typename R, typename T> template<typename R, typename T>
inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc, inline Ptrdiff format_ritem(R &writer, Size &fmtn, bool esc,
bool expandval, ConstCharRange fmt, bool expandval, ConstCharRange fmt,
const T &item, T const &item,
EnableIf<IsTupleLike<T>, bool> EnableIf<IsTupleLike<T>, bool>
= true) { = true) {
if (expandval) { if (expandval) {
@ -511,10 +510,10 @@ namespace detail {
} }
template<typename R, typename T> template<typename R, typename T>
inline Ptrdiff write_range(R &writer, const FormatSpec *fl, inline Ptrdiff write_range(R &writer, FormatSpec const *fl,
bool escape, bool expandval, bool escape, bool expandval,
ConstCharRange sep, ConstCharRange sep,
const T &val, T const &val,
EnableIf<FmtRangeTest<T>, bool> EnableIf<FmtRangeTest<T>, bool>
= true) { = true) {
auto range = ostd::iter(val); auto range = ostd::iter(val);
@ -542,8 +541,8 @@ namespace detail {
} }
template<typename R, typename T> template<typename R, typename T>
inline Ptrdiff write_range(R &, const FormatSpec *, bool, bool, inline Ptrdiff write_range(R &, FormatSpec const *, bool, bool,
ConstCharRange, const T &, ConstCharRange, T const &,
EnableIf<!FmtRangeTest<T>, bool> EnableIf<!FmtRangeTest<T>, bool>
= true) { = true) {
assert(false && "invalid value for ranged format"); assert(false && "invalid value for ranged format");
@ -558,7 +557,7 @@ namespace detail {
constexpr bool FmtTostrTest = decltype(test_fmt_tostr<T>(0))::value; constexpr bool FmtTostrTest = decltype(test_fmt_tostr<T>(0))::value;
/* non-printable escapes up to 0x20 (space) */ /* non-printable escapes up to 0x20 (space) */
static constexpr const char *fmt_escapes[] = { static constexpr char const *fmt_escapes[] = {
"\\0" , "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\0" , "\\x01", "\\x02", "\\x03", "\\x04", "\\x05",
"\\x06", "\\a" , "\\b" , "\\t" , "\\n" , "\\v" , "\\x06", "\\a" , "\\b" , "\\t" , "\\n" , "\\v" ,
"\\f" , "\\r" , "\\x0E", "\\x0F", "\\x10", "\\x11", "\\f" , "\\r" , "\\x0E", "\\x0F", "\\x10", "\\x11",
@ -570,7 +569,7 @@ namespace detail {
nullptr, "\\\'" nullptr, "\\\'"
}; };
inline const char *escape_fmt_char(char v, char quote) { inline char const *escape_fmt_char(char v, char quote) {
if ((v >= 0 && v < 0x20) || (v == quote)) { if ((v >= 0 && v < 0x20) || (v == quote)) {
return fmt_escapes[Size(v)]; return fmt_escapes[Size(v)];
} else if (v == 0x7F) { } else if (v == 0x7F) {
@ -583,7 +582,7 @@ namespace detail {
String ret; String ret;
ret.push('"'); ret.push('"');
while (!val.empty()) { while (!val.empty()) {
const char *esc = escape_fmt_char(val.front(), '"'); char const *esc = escape_fmt_char(val.front(), '"');
if (esc) if (esc)
ret.append(esc); ret.append(esc);
else else
@ -595,9 +594,9 @@ namespace detail {
} }
template<typename T, typename R> template<typename T, typename R>
static True test_tofmt(decltype(to_format(declval<const T &>(), static True test_tofmt(decltype(to_format(declval<T const &>(),
declval<R &>(), declval<R &>(),
declval<const FormatSpec &>())) *); declval<FormatSpec const &>())) *);
template<typename, typename> template<typename, typename>
static False test_tofmt(...); static False test_tofmt(...);
@ -626,8 +625,8 @@ namespace detail {
/* any string value */ /* any string value */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write(R &writer, bool escape, const T &val, EnableIf< Ptrdiff write(R &writer, bool escape, T const &val, EnableIf<
IsConstructible<ConstCharRange, const T &>, bool IsConstructible<ConstCharRange, T const &>, bool
> = true) { > = true) {
if (this->spec() != 's') { if (this->spec() != 's') {
assert(false && "cannot print strings with the given spec"); assert(false && "cannot print strings with the given spec");
@ -644,14 +643,14 @@ namespace detail {
return -1; return -1;
} }
if (escape) { if (escape) {
const char *esc = escape_fmt_char(val, '\''); char const *esc = escape_fmt_char(val, '\'');
if (esc) { if (esc) {
char buf[6]; char buf[6];
buf[0] = '\''; buf[0] = '\'';
Size elen = strlen(esc); Size elen = strlen(esc);
memcpy(buf + 1, esc, elen); memcpy(buf + 1, esc, elen);
buf[elen + 1] = '\''; buf[elen + 1] = '\'';
return write(writer, false, (const char *)buf, elen + 2); return write(writer, false, (char const *)buf, elen + 2);
} }
} }
Ptrdiff r = 1 + escape * 2; Ptrdiff r = 1 + escape * 2;
@ -738,9 +737,9 @@ namespace detail {
/* generic value */ /* generic value */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write(R &writer, bool, const T &val, EnableIf< Ptrdiff write(R &writer, bool, T const &val, EnableIf<
!IsArithmetic<T> && !IsArithmetic<T> &&
!IsConstructible<ConstCharRange, const T &> && !IsConstructible<ConstCharRange, T const &> &&
FmtTostrTest<T> && !FmtTofmtTest<T, TostrRange<R>>, bool FmtTostrTest<T> && !FmtTofmtTest<T, TostrRange<R>>, bool
> = true) { > = true) {
if (this->spec() != 's') { if (this->spec() != 's') {
@ -752,7 +751,7 @@ namespace detail {
/* custom format case */ /* custom format case */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write(R &writer, bool, const T &val, Ptrdiff write(R &writer, bool, T const &val,
EnableIf<FmtTofmtTest<T, TostrRange<R>>, bool EnableIf<FmtTofmtTest<T, TostrRange<R>>, bool
> = true) { > = true) {
TostrRange<R> sink(writer); TostrRange<R> sink(writer);
@ -762,9 +761,9 @@ namespace detail {
/* generic failure case */ /* generic failure case */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write(R &, bool, const T &, EnableIf< Ptrdiff write(R &, bool, T const &, EnableIf<
!IsArithmetic<T> && !IsArithmetic<T> &&
!IsConstructible<ConstCharRange, const T &> && !IsConstructible<ConstCharRange, T const &> &&
!FmtTostrTest<T> && !FmtTofmtTest<T, TostrRange<R>>, bool !FmtTostrTest<T> && !FmtTofmtTest<T, TostrRange<R>>, bool
> = true) { > = true) {
assert(false && "value cannot be formatted"); assert(false && "value cannot be formatted");
@ -773,7 +772,7 @@ namespace detail {
/* actual writer */ /* actual writer */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write_arg(R &writer, Size idx, const T &val) { Ptrdiff write_arg(R &writer, Size idx, T const &val) {
if (idx) { if (idx) {
assert(false && "not enough format args"); assert(false && "not enough format args");
return -1; return -1;
@ -782,8 +781,8 @@ namespace detail {
} }
template<typename R, typename T, typename ...A> template<typename R, typename T, typename ...A>
Ptrdiff write_arg(R &writer, Size idx, const T &val, Ptrdiff write_arg(R &writer, Size idx, T const &val,
const A &...args) { A const &...args) {
if (idx) return write_arg(writer, idx - 1, args...); if (idx) return write_arg(writer, idx - 1, args...);
return write(writer, this->p_nested_escape, val); return write(writer, this->p_nested_escape, val);
} }
@ -791,7 +790,7 @@ namespace detail {
/* range writer */ /* range writer */
template<typename R, typename T> template<typename R, typename T>
Ptrdiff write_range(R &writer, Size idx, bool expandval, Ptrdiff write_range(R &writer, Size idx, bool expandval,
ConstCharRange sep, const T &val) { ConstCharRange sep, T const &val) {
if (idx) { if (idx) {
assert(false && "not enough format args"); assert(false && "not enough format args");
return -1; return -1;
@ -802,8 +801,8 @@ namespace detail {
template<typename R, typename T, typename ...A> template<typename R, typename T, typename ...A>
Ptrdiff write_range(R &writer, Size idx, bool expandval, Ptrdiff write_range(R &writer, Size idx, bool expandval,
ConstCharRange sep, const T &val, ConstCharRange sep, T const &val,
const A &...args) { A const &...args) {
if (idx) { if (idx) {
return write_range(writer, idx - 1, expandval, sep, args...); return write_range(writer, idx - 1, expandval, sep, args...);
} }
@ -814,7 +813,7 @@ namespace detail {
template<typename R, typename ...A> template<typename R, typename ...A>
inline Ptrdiff format_impl(R &writer, Size &fmtn, bool escape, inline Ptrdiff format_impl(R &writer, Size &fmtn, bool escape,
ConstCharRange fmt, const A &...args) { ConstCharRange fmt, A const &...args) {
Size argidx = 1, retn = 0, twr = 0; Size argidx = 1, retn = 0, twr = 0;
Ptrdiff written = 0; Ptrdiff written = 0;
detail::WriteSpec spec(fmt, escape); detail::WriteSpec spec(fmt, escape);
@ -885,12 +884,12 @@ namespace detail {
template<typename R, typename ...A> template<typename R, typename ...A>
inline Ptrdiff format(R &&writer, Size &fmtn, ConstCharRange fmt, inline Ptrdiff format(R &&writer, Size &fmtn, ConstCharRange fmt,
const A &...args) { A const &...args) {
return detail::format_impl(writer, fmtn, false, fmt, args...); return detail::format_impl(writer, fmtn, false, fmt, args...);
} }
template<typename R, typename ...A> template<typename R, typename ...A>
Ptrdiff format(R &&writer, ConstCharRange fmt, const A &...args) { Ptrdiff format(R &&writer, ConstCharRange fmt, A const &...args) {
Size fmtn = 0; Size fmtn = 0;
return format(writer, fmtn, fmt, args...); return format(writer, fmtn, fmt, args...);
} }

130
ostd/functional.hh
View File

@ -20,7 +20,7 @@ namespace ostd {
#define OSTD_DEFINE_BINARY_OP(name, op, RT) \ #define OSTD_DEFINE_BINARY_OP(name, op, RT) \
template<typename T> struct name { \ template<typename T> struct name { \
RT operator()(const T &x, const T &y) const { \ RT operator()(T const &x, T const &y) const { \
return x op y; \ return x op y; \
} \ } \
using FirstArgument = T; \ using FirstArgument = T; \
@ -71,7 +71,7 @@ namespace detail {
template<typename T> struct EqualWithCstr { template<typename T> struct EqualWithCstr {
using FirstArgument = T; using FirstArgument = T;
using SecondArgument = T; using SecondArgument = T;
bool operator()(const T &x, const T &y) const { bool operator()(T const &x, T const &y) const {
return x == y; return x == y;
} }
}; };
@ -79,13 +79,13 @@ template<typename T> struct EqualWithCstr {
template<typename T> struct EqualWithCstr<T *>: detail::CharEqual<T> {}; template<typename T> struct EqualWithCstr<T *>: detail::CharEqual<T> {};
template<typename T> struct LogicalNot { template<typename T> struct LogicalNot {
bool operator()(const T &x) const { return !x; } bool operator()(T const &x) const { return !x; }
using Argument = T; using Argument = T;
using Result = bool; using Result = bool;
}; };
template<typename T> struct Negate { template<typename T> struct Negate {
bool operator()(const T &x) const { return -x; } bool operator()(T const &x) const { return -x; }
using Argument = T; using Argument = T;
using Result = T; using Result = T;
}; };
@ -95,10 +95,10 @@ template<typename T> struct BinaryNegate {
using SecondArgument = typename T::SecondArgument; using SecondArgument = typename T::SecondArgument;
using Result = bool; using Result = bool;
explicit BinaryNegate(const T &f): p_fn(f) {} explicit BinaryNegate(T const &f): p_fn(f) {}
bool operator()(const FirstArgument &x, bool operator()(FirstArgument const &x,
const SecondArgument &y) { SecondArgument const &y) {
return !p_fn(x, y); return !p_fn(x, y);
} }
private: private:
@ -109,19 +109,19 @@ template<typename T> struct UnaryNegate {
using Argument = typename T::Argument; using Argument = typename T::Argument;
using Result = bool; using Result = bool;
explicit UnaryNegate(const T &f): p_fn(f) {} explicit UnaryNegate(T const &f): p_fn(f) {}
bool operator()(const Argument &x) { bool operator()(Argument const &x) {
return !p_fn(x); return !p_fn(x);
} }
private: private:
T p_fn; T p_fn;
}; };
template<typename T> UnaryNegate<T> not1(const T &fn) { template<typename T> UnaryNegate<T> not1(T const &fn) {
return UnaryNegate<T>(fn); return UnaryNegate<T>(fn);
} }
template<typename T> BinaryNegate<T> not2(const T &fn) { template<typename T> BinaryNegate<T> not2(T const &fn) {
return BinaryNegate<T>(fn); return BinaryNegate<T>(fn);
} }
@ -210,7 +210,7 @@ template<typename T> struct ToHash {
using Argument = T; using Argument = T;
using Result = Size; using Result = Size;
Size operator()(const T &v) const { Size operator()(T const &v) const {
return v.to_hash(); return v.to_hash();
} }
}; };
@ -262,11 +262,11 @@ namespace detail {
static constexpr Size offset = Size(14695981039346656037u); static constexpr Size offset = Size(14695981039346656037u);
}; };
inline Size mem_hash(const void *p, Size l) { inline Size mem_hash(void const *p, Size l) {
using Consts = FnvConstants<sizeof(Size)>; using Consts = FnvConstants<sizeof(Size)>;
const byte *d = (const byte *)p; byte const *d = (byte const *)p;
Size h = Consts::offset; Size h = Consts::offset;
for (const byte *it = d, *end = d + l; it != end; ++it) { for (byte const *it = d, *end = d + l; it != end; ++it) {
h ^= *it; h ^= *it;
h *= Consts::prime; h *= Consts::prime;
} }
@ -306,7 +306,7 @@ namespace detail {
Size operator()(T v) const { Size operator()(T v) const {
union { T v; struct { Size h1, h2; }; } u; union { T v; struct { Size h1, h2; }; } u;
u.v = v; u.v = v;
return mem_hash((const void *)&u, sizeof(u)); return mem_hash((void const *)&u, sizeof(u));
} }
}; };
@ -317,7 +317,7 @@ namespace detail {
Size operator()(T v) const { Size operator()(T v) const {
union { T v; struct { Size h1, h2, h3; }; } u; union { T v; struct { Size h1, h2, h3; }; } u;
u.v = v; u.v = v;
return mem_hash((const void *)&u, sizeof(u)); return mem_hash((void const *)&u, sizeof(u));
} }
}; };
@ -328,7 +328,7 @@ namespace detail {
Size operator()(T v) const { Size operator()(T v) const {
union { T v; struct { Size h1, h2, h3, h4; }; } u; union { T v; struct { Size h1, h2, h3, h4; }; } u;
u.v = v; u.v = v;
return mem_hash((const void *)&u, sizeof(u)); return mem_hash((void const *)&u, sizeof(u));
} }
}; };
} /* namespace detail */ } /* namespace detail */
@ -379,7 +379,7 @@ namespace detail {
Size operator()(T *v) const { Size operator()(T *v) const {
union { T *v; Size h; } u; union { T *v; Size h; } u;
u.v = v; u.v = v;
return detail::mem_hash((const void *)&u, sizeof(u)); return detail::mem_hash((void const *)&u, sizeof(u));
} }
}; };
@ -395,7 +395,7 @@ namespace detail {
template<typename T> struct ToHash<T *>: detail::ToHashPtr<T> {}; template<typename T> struct ToHash<T *>: detail::ToHashPtr<T> {};
template<typename T> template<typename T>
typename ToHash<T>::Result to_hash(const T &v) { typename ToHash<T>::Result to_hash(T const &v) {
return ToHash<T>()(v); return ToHash<T>()(v);
} }
@ -406,10 +406,10 @@ struct ReferenceWrapper {
using Type = T; using Type = T;
ReferenceWrapper(T &v): p_ptr(address_of(v)) {} ReferenceWrapper(T &v): p_ptr(address_of(v)) {}
ReferenceWrapper(const ReferenceWrapper &) = default; ReferenceWrapper(ReferenceWrapper const &) = default;
ReferenceWrapper(T &&) = delete; ReferenceWrapper(T &&) = delete;
ReferenceWrapper &operator=(const ReferenceWrapper &) = default; ReferenceWrapper &operator=(ReferenceWrapper const &) = default;
operator T &() const { return *p_ptr; } operator T &() const { return *p_ptr; }
T &get() const { return *p_ptr; } T &get() const { return *p_ptr; }
@ -426,17 +426,17 @@ template<typename T>
ReferenceWrapper<T> ref(ReferenceWrapper<T> v) { ReferenceWrapper<T> ref(ReferenceWrapper<T> v) {
return ReferenceWrapper<T>(v); return ReferenceWrapper<T>(v);
} }
template<typename T> void ref(const T &&) = delete; template<typename T> void ref(T const &&) = delete;
template<typename T> template<typename T>
ReferenceWrapper<const T> cref(const T &v) { ReferenceWrapper<T const> cref(T const &v) {
return ReferenceWrapper<T>(v); return ReferenceWrapper<T>(v);
} }
template<typename T> template<typename T>
ReferenceWrapper<const T> cref(ReferenceWrapper<T> v) { ReferenceWrapper<T const> cref(ReferenceWrapper<T> v) {
return ReferenceWrapper<T>(v); return ReferenceWrapper<T>(v);
} }
template<typename T> void cref(const T &&) = delete; template<typename T> void cref(T const &&) = delete;
/* mem_fn */ /* mem_fn */
@ -456,12 +456,12 @@ namespace detail {
template<typename T, typename R, typename ...A> template<typename T, typename R, typename ...A>
struct MemTypes<T, R(A...) const> { struct MemTypes<T, R(A...) const> {
using Result = R; using Result = R;
using Argument = const T; using Argument = T const;
}; };
template<typename T, typename R, typename A> template<typename T, typename R, typename A>
struct MemTypes<T, R(A) const> { struct MemTypes<T, R(A) const> {
using Result = R; using Result = R;
using FirstArgument = const T; using FirstArgument = T const;
using SecondArgument = A; using SecondArgument = A;
}; };
@ -476,7 +476,7 @@ namespace detail {
return ((obj).*(p_ptr))(forward<A>(args)...); return ((obj).*(p_ptr))(forward<A>(args)...);
} }
template<typename... A> template<typename... A>
auto operator()(const T &obj, A &&...args) -> auto operator()(T const &obj, A &&...args) ->
decltype(((obj).*(p_ptr))(forward<A>(args)...)) const { decltype(((obj).*(p_ptr))(forward<A>(args)...)) const {
return ((obj).*(p_ptr))(forward<A>(args)...); return ((obj).*(p_ptr))(forward<A>(args)...);
} }
@ -486,7 +486,7 @@ namespace detail {
return ((obj)->*(p_ptr))(forward<A>(args)...); return ((obj)->*(p_ptr))(forward<A>(args)...);
} }
template<typename... A> template<typename... A>
auto operator()(const T *obj, A &&...args) -> auto operator()(T const *obj, A &&...args) ->
decltype(((obj)->*(p_ptr))(forward<A>(args)...)) const { decltype(((obj)->*(p_ptr))(forward<A>(args)...)) const {
return ((obj)->*(p_ptr))(forward<A>(args)...); return ((obj)->*(p_ptr))(forward<A>(args)...);
} }
@ -518,22 +518,22 @@ namespace detail {
struct FmStorage { struct FmStorage {
FunctorData data; FunctorData data;
const FunctionManager *manager; FunctionManager const *manager;
template<typename A> template<typename A>
A &get_alloc() { A &get_alloc() {
union { union {
const FunctionManager **m; FunctionManager const **m;
A *alloc; A *alloc;
} u; } u;
u.m = &manager; u.m = &manager;
return *u.alloc; return *u.alloc;
} }
template<typename A> template<typename A>
const A &get_alloc() const { A const &get_alloc() const {
union { union {
const FunctionManager * const *m; FunctionManager const * const *m;
const A *alloc; A const *alloc;
} u; } u;
u.m = &manager; u.m = &manager;
return *u.alloc; return *u.alloc;
@ -543,7 +543,7 @@ namespace detail {
template<typename T, typename A, typename E = void> template<typename T, typename A, typename E = void>
struct FunctorDataManager { struct FunctorDataManager {
template<typename R, typename ...Args> template<typename R, typename ...Args>
static R call(const FunctorData &s, Args ...args) { static R call(FunctorData const &s, Args ...args) {
return ((T &)s)(forward<Args>(args)...); return ((T &)s)(forward<Args>(args)...);
} }
@ -559,9 +559,9 @@ namespace detail {
get_ref(s).~T(); get_ref(s).~T();
} }
static T &get_ref(const FmStorage &s) { static T &get_ref(FmStorage const &s) {
union { union {
const FunctorData *data; FunctorData const *data;
T *ret; T *ret;
} u; } u;
u.data = &s.data; u.data = &s.data;
@ -572,7 +572,7 @@ namespace detail {
template<typename T, typename A> template<typename T, typename A>
struct FunctorDataManager<T, A, EnableIf<!FunctorInPlace<T>>> { struct FunctorDataManager<T, A, EnableIf<!FunctorInPlace<T>>> {
template<typename R, typename ...Args> template<typename R, typename ...Args>
static R call(const FunctorData &s, Args ...args) { static R call(FunctorData const &s, Args ...args) {
return (*(AllocatorPointer<A> &)s)(forward<Args>(args)...); return (*(AllocatorPointer<A> &)s)(forward<Args>(args)...);
} }
@ -596,7 +596,7 @@ namespace detail {
ptr = nullptr; ptr = nullptr;
} }
static T &get_ref(const FmStorage &s) { static T &get_ref(FmStorage const &s) {
return *get_ptr_ref(s); return *get_ptr_ref(s);
} }
@ -604,13 +604,13 @@ namespace detail {
return (AllocatorPointer<A> &)(s.data); return (AllocatorPointer<A> &)(s.data);
} }
static AllocatorPointer<A> &get_ptr_ref(const FmStorage &s) { static AllocatorPointer<A> &get_ptr_ref(FmStorage const &s) {
return (AllocatorPointer<A> &)(s.data); return (AllocatorPointer<A> &)(s.data);
} }
}; };
template<typename T, typename A> template<typename T, typename A>
static const FunctionManager &get_default_fm(); static FunctionManager const &get_default_fm();
template<typename T, typename A> template<typename T, typename A>
static void create_fm(FmStorage &s, A &&a) { static void create_fm(FmStorage &s, A &&a) {
@ -632,14 +632,14 @@ namespace detail {
void (* const call_move_and_destroyf)(FmStorage &lhs, void (* const call_move_and_destroyf)(FmStorage &lhs,
FmStorage &&rhs); FmStorage &&rhs);
void (* const call_copyf)(FmStorage &lhs, void (* const call_copyf)(FmStorage &lhs,
const FmStorage &rhs); FmStorage const &rhs);
void (* const call_copyf_fo)(FmStorage &lhs, void (* const call_copyf_fo)(FmStorage &lhs,
const FmStorage &rhs); FmStorage const &rhs);
void (* const call_destroyf)(FmStorage &s); void (* const call_destroyf)(FmStorage &s);
template<typename T, typename A> template<typename T, typename A>
static void call_move_and_destroy(FmStorage &lhs, static void call_move_and_destroy(FmStorage &lhs,
FmStorage &&rhs) { FmStorage &&rhs) {
using Spec = FunctorDataManager<T, A>; using Spec = FunctorDataManager<T, A>;
Spec::move_f(lhs, move(rhs)); Spec::move_f(lhs, move(rhs));
Spec::destroy_f(rhs.get_alloc<A>(), rhs); Spec::destroy_f(rhs.get_alloc<A>(), rhs);
@ -649,7 +649,7 @@ namespace detail {
template<typename T, typename A> template<typename T, typename A>
static void call_copy(FmStorage &lhs, static void call_copy(FmStorage &lhs,
const FmStorage &rhs) { FmStorage const &rhs) {
using Spec = FunctorDataManager<T, A>; using Spec = FunctorDataManager<T, A>;
create_fm<T, A>(lhs, A(rhs.get_alloc<A>())); create_fm<T, A>(lhs, A(rhs.get_alloc<A>()));
Spec::store_f(lhs, Spec::get_ref(rhs)); Spec::store_f(lhs, Spec::get_ref(rhs));
@ -657,7 +657,7 @@ namespace detail {
template<typename T, typename A> template<typename T, typename A>
static void call_copy_fo(FmStorage &lhs, static void call_copy_fo(FmStorage &lhs,
const FmStorage &rhs) { FmStorage const &rhs) {
using Spec = FunctorDataManager<T, A>; using Spec = FunctorDataManager<T, A>;
Spec::store_f(lhs, Spec::get_ref(rhs)); Spec::store_f(lhs, Spec::get_ref(rhs));
} }
@ -671,8 +671,8 @@ namespace detail {
}; };
template<typename T, typename A> template<typename T, typename A>
inline static const FunctionManager &get_default_fm() { inline static FunctionManager const &get_default_fm() {
static const FunctionManager def_manager static FunctionManager const def_manager
= FunctionManager::create_default_manager<T, A>(); = FunctionManager::create_default_manager<T, A>();
return def_manager; return def_manager;
} }
@ -744,7 +744,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
swap(f); swap(f);
} }
Function(const Function &f): p_call(f.p_call) { Function(Function const &f): p_call(f.p_call) {
f.p_stor.manager->call_copyf(p_stor, f.p_stor); f.p_stor.manager->call_copyf(p_stor, f.p_stor);
} }
@ -760,21 +760,21 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
} }
template<typename A> template<typename A>
Function(AllocatorArg, const A &) { init_empty(); } Function(AllocatorArg, A const &) { init_empty(); }
template<typename A> template<typename A>
Function(AllocatorArg, const A &, Nullptr) { init_empty(); } Function(AllocatorArg, A const &, Nullptr) { init_empty(); }
template<typename A> template<typename A>
Function(AllocatorArg, const A &, Function &&f) { Function(AllocatorArg, A const &, Function &&f) {
init_empty(); init_empty();
swap(f); swap(f);
} }
template<typename A> template<typename A>
Function(AllocatorArg, const A &a, const Function &f): Function(AllocatorArg, A const &a, Function const &f):
p_call(f.p_call) { p_call(f.p_call) {
const detail::FunctionManager *mfa detail::FunctionManager const *mfa
= &detail::get_default_fm<AllocatorValue<A>, A>(); = &detail::get_default_fm<AllocatorValue<A>, A>();
if (f.p_stor.manager == mfa) { if (f.p_stor.manager == mfa) {
detail::create_fm<AllocatorValue<A>, A>(p_stor, A(a)); detail::create_fm<AllocatorValue<A>, A>(p_stor, A(a));
@ -783,7 +783,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
} }
using AA = AllocatorRebind<A, Function>; using AA = AllocatorRebind<A, Function>;
const detail::FunctionManager *mff detail::FunctionManager const *mff
= &detail::get_default_fm<Function, AA>(); = &detail::get_default_fm<Function, AA>();
if (f.p_stor.manager == mff) { if (f.p_stor.manager == mff) {
detail::create_fm<Function, AA>(p_stor, AA(a)); detail::create_fm<Function, AA>(p_stor, AA(a));
@ -796,7 +796,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
template<typename A, typename T, typename = EnableIf< template<typename A, typename T, typename = EnableIf<
detail::IsValidFunctor<T, R(Args...)> detail::IsValidFunctor<T, R(Args...)>
>> Function(AllocatorArg, const A &a, T f) { >> Function(AllocatorArg, A const &a, T f) {
if (func_is_null(f)) { if (func_is_null(f)) {
init_empty(); init_empty();
return; return;
@ -814,7 +814,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
return *this; return *this;
} }
Function &operator=(const Function &f) { Function &operator=(Function const &f) {
p_stor.manager->call_destroyf(p_stor); p_stor.manager->call_destroyf(p_stor);
swap(Function(f)); swap(Function(f));
return *this; return *this;
@ -825,7 +825,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
} }
template<typename F, typename A> template<typename F, typename A>
void assign(F &&f, const A &a) { void assign(F &&f, A const &a) {
Function(allocator_arg, a, forward<F>(f)).swap(*this); Function(allocator_arg, a, forward<F>(f)).swap(*this);
} }
@ -841,7 +841,7 @@ struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
private: private:
detail::FmStorage p_stor; detail::FmStorage p_stor;
R (*p_call)(const detail::FunctorData &, Args...); R (*p_call)(detail::FunctorData const &, Args...);
template<typename T, typename A> template<typename T, typename A>
void initialize(T &&f, A &&a) { void initialize(T &&f, A &&a) {
@ -860,7 +860,7 @@ private:
} }
template<typename T> template<typename T>
static bool func_is_null(const T &) { return false; } static bool func_is_null(T const &) { return false; }
static bool func_is_null(R (* const &fptr)(Args...)) { static bool func_is_null(R (* const &fptr)(Args...)) {
return fptr == nullptr; return fptr == nullptr;
@ -878,16 +878,16 @@ private:
}; };
template<typename T> template<typename T>
bool operator==(Nullptr, const Function<T> &rhs) { return !rhs; } bool operator==(Nullptr, Function<T> const &rhs) { return !rhs; }
template<typename T> template<typename T>
bool operator==(const Function<T> &lhs, Nullptr) { return !lhs; } bool operator==(Function<T> const &lhs, Nullptr) { return !lhs; }
template<typename T> template<typename T>
bool operator!=(Nullptr, const Function<T> &rhs) { return rhs; } bool operator!=(Nullptr, Function<T> const &rhs) { return rhs; }
template<typename T> template<typename T>
bool operator!=(const Function<T> &lhs, Nullptr) { return lhs; } bool operator!=(Function<T> const &lhs, Nullptr) { return lhs; }
namespace detail { namespace detail {
template<typename F> template<typename F>

16
ostd/initializer_list.hh
View File

@ -16,17 +16,17 @@ namespace std {
template<typename T> template<typename T>
class initializer_list { class initializer_list {
const T *p_buf; T const *p_buf;
ostd::Size p_len; ostd::Size p_len;
constexpr initializer_list(const T *v, ostd::Size n): p_buf(v), p_len(n) {} constexpr initializer_list(T const *v, ostd::Size n): p_buf(v), p_len(n) {}
public: public:
constexpr initializer_list(): p_buf(nullptr), p_len(0) {} constexpr initializer_list(): p_buf(nullptr), p_len(0) {}
constexpr ostd::Size size() const { return p_len; } constexpr ostd::Size size() const { return p_len; }
constexpr const T *begin() const { return p_buf; } constexpr T const *begin() const { return p_buf; }
constexpr const T *end() const { return p_buf + p_len; } constexpr T const *end() const { return p_buf + p_len; }
}; };
} }
@ -39,13 +39,13 @@ namespace ostd {
template<typename T> using InitializerList = std::initializer_list<T>; template<typename T> using InitializerList = std::initializer_list<T>;
template<typename T> template<typename T>
PointerRange<const T> iter(std::initializer_list<T> init) { PointerRange<T const> iter(std::initializer_list<T> init) {
return PointerRange<const T>(init.begin(), init.end()); return PointerRange<T const>(init.begin(), init.end());
} }
template<typename T> template<typename T>
PointerRange<const T> citer(std::initializer_list<T> init) { PointerRange<T const> citer(std::initializer_list<T> init) {
return PointerRange<const T>(init.begin(), init.end()); return PointerRange<T const>(init.begin(), init.end());
} }
} }

24
ostd/io.hh
View File

@ -20,14 +20,14 @@ enum class StreamMode {
}; };
namespace detail { namespace detail {
static const char *filemodes[] = { static char const *filemodes[] = {
"rb", "wb", "ab", "rb+", "wb+", "ab+" "rb", "wb", "ab", "rb+", "wb+", "ab+"
}; };
} }
struct FileStream: Stream { struct FileStream: Stream {
FileStream(): p_f(), p_owned(false) {} FileStream(): p_f(), p_owned(false) {}
FileStream(const FileStream &) = delete; FileStream(FileStream const &) = delete;
FileStream(FileStream &&s): p_f(s.p_f), p_owned(s.p_owned) { FileStream(FileStream &&s): p_f(s.p_f), p_owned(s.p_owned) {
s.p_f = nullptr; s.p_f = nullptr;
s.p_owned = false; s.p_owned = false;
@ -41,7 +41,7 @@ struct FileStream: Stream {
~FileStream() { close(); } ~FileStream() { close(); }
FileStream &operator=(const FileStream &) = delete; FileStream &operator=(FileStream const &) = delete;
FileStream &operator=(FileStream &&s) { FileStream &operator=(FileStream &&s) {
close(); close();
swap(s); swap(s);
@ -100,7 +100,7 @@ struct FileStream: Stream {
return fread(buf, 1, count, p_f); return fread(buf, 1, count, p_f);
} }
Size write_bytes(const void *buf, Size count) { Size write_bytes(void const *buf, Size count) {
return fwrite(buf, 1, count, p_f); return fwrite(buf, 1, count, p_f);
} }
@ -138,39 +138,39 @@ namespace detail {
} }
template<typename T> template<typename T>
inline void write_impl(const T &v, EnableIf< inline void write_impl(T const &v, EnableIf<
!IsConstructible<ConstCharRange, const T &>, IoNat !IsConstructible<ConstCharRange, T const &>, IoNat
> = IoNat()) { > = IoNat()) {
write(ostd::to_string(v)); write(ostd::to_string(v));
} }
} }
template<typename T> template<typename T>
inline void write(const T &v) { inline void write(T const &v) {
detail::write_impl(v); detail::write_impl(v);
} }
template<typename T, typename ...A> template<typename T, typename ...A>
inline void write(const T &v, const A &...args) { inline void write(T const &v, A const &...args) {
write(v); write(v);
write(args...); write(args...);
} }
template<typename T> template<typename T>
inline void writeln(const T &v) { inline void writeln(T const &v) {
write(v); write(v);
putc('\n', ::stdout); putc('\n', ::stdout);
} }
template<typename T, typename ...A> template<typename T, typename ...A>
inline void writeln(const T &v, const A &...args) { inline void writeln(T const &v, A const &...args) {
write(v); write(v);
write(args...); write(args...);
putc('\n', ::stdout); putc('\n', ::stdout);
} }
template<typename ...A> template<typename ...A>
inline void writef(ConstCharRange fmt, const A &...args) { inline void writef(ConstCharRange fmt, A const &...args) {
char buf[512]; char buf[512];
Ptrdiff need = format(detail::FormatOutRange<sizeof(buf)>(buf), Ptrdiff need = format(detail::FormatOutRange<sizeof(buf)>(buf),
fmt, args...); fmt, args...);
@ -186,7 +186,7 @@ inline void writef(ConstCharRange fmt, const A &...args) {
} }
template<typename ...A> template<typename ...A>
inline void writefln(ConstCharRange fmt, const A &...args) { inline void writefln(ConstCharRange fmt, A const &...args) {
writef(fmt, args...); writef(fmt, args...);
putc('\n', ::stdout); putc('\n', ::stdout);
} }

52
ostd/keyset.hh
View File

@ -19,22 +19,22 @@ namespace ostd {
namespace detail { namespace detail {
template<typename T> template<typename T>
using KeysetKeyRet = decltype(declval<const T &>().get_key()); using KeysetKeyRet = decltype(declval<T const &>().get_key());
template<typename T> template<typename T>
using KeysetKey = const Decay<KeysetKeyRet<T>>; using KeysetKey = Decay<KeysetKeyRet<T>> const;
template<typename T, typename A> struct KeysetBase { template<typename T, typename A> struct KeysetBase {
using Key = KeysetKey<T>; using Key = KeysetKey<T>;
using RetKey = Conditional<IsReference<KeysetKeyRet<T>>, Key &, Key>; using RetKey = Conditional<IsReference<KeysetKeyRet<T>>, Key &, Key>;
static inline RetKey get_key(const T &e) { static inline RetKey get_key(T const &e) {
return e.get_key(); return e.get_key();
} }
static inline T &get_data(T &e) { static inline T &get_data(T &e) {
return e; return e;
} }
template<typename U> template<typename U>
static inline void set_key(T &, const U &, A &) {} static inline void set_key(T &, U const &, A &) {}
static inline void swap_elem(T &a, T &b) { swap_adl(a, b); } static inline void swap_elem(T &a, T &b) { swap_adl(a, b); }
}; };
@ -60,35 +60,35 @@ namespace detail {
using Pointer = AllocatorPointer<A>; using Pointer = AllocatorPointer<A>;
using ConstPointer = AllocatorConstPointer<A>; using ConstPointer = AllocatorConstPointer<A>;
using Range = HashRange<T>; using Range = HashRange<T>;
using ConstRange = HashRange<const T>; using ConstRange = HashRange<T const>;
using LocalRange = BucketRange<T>; using LocalRange = BucketRange<T>;
using ConstLocalRange = BucketRange<const T>; using ConstLocalRange = BucketRange<T const>;
using Allocator = A; using Allocator = A;
explicit KeysetImpl(Size size, const H &hf = H(), explicit KeysetImpl(Size size, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size, hf, eqf, alloc) {} ): Base(size, hf, eqf, alloc) {}
KeysetImpl(): KeysetImpl(0) {} KeysetImpl(): KeysetImpl(0) {}
explicit KeysetImpl(const A &alloc): KeysetImpl(0, H(), C(), alloc) {} explicit KeysetImpl(A const &alloc): KeysetImpl(0, H(), C(), alloc) {}
KeysetImpl(Size size, const A &alloc): KeysetImpl(Size size, A const &alloc):
KeysetImpl(size, H(), C(), alloc) {} KeysetImpl(size, H(), C(), alloc) {}
KeysetImpl(Size size, const H &hf, const A &alloc): KeysetImpl(Size size, H const &hf, A const &alloc):
KeysetImpl(size, hf, C(), alloc) {} KeysetImpl(size, hf, C(), alloc) {}
KeysetImpl(const KeysetImpl &m): Base(m, KeysetImpl(KeysetImpl const &m): Base(m,
allocator_container_copy(m.get_alloc())) {} allocator_container_copy(m.get_alloc())) {}
KeysetImpl(const KeysetImpl &m, const A &alloc): Base(m, alloc) {} KeysetImpl(KeysetImpl const &m, A const &alloc): Base(m, alloc) {}
KeysetImpl(KeysetImpl &&m): Base(move(m)) {} KeysetImpl(KeysetImpl &&m): Base(move(m)) {}
KeysetImpl(KeysetImpl &&m, const A &alloc): Base(move(m), alloc) {} KeysetImpl(KeysetImpl &&m, A const &alloc): Base(move(m), alloc) {}
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> KeysetImpl(R range, Size size = 0, const H &hf = H(), >> KeysetImpl(R range, Size size = 0, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size ? size : detail::estimate_hrsize(range), ): Base(size ? size : detail::estimate_hrsize(range),
hf, eqf, alloc) { hf, eqf, alloc) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
@ -97,25 +97,25 @@ namespace detail {
} }
template<typename R> template<typename R>
KeysetImpl(R range, Size size, const A &alloc) KeysetImpl(R range, Size size, A const &alloc)
: KeysetImpl(range, size, H(), C(), alloc) {} : KeysetImpl(range, size, H(), C(), alloc) {}
template<typename R> template<typename R>
KeysetImpl(R range, Size size, const H &hf, const A &alloc) KeysetImpl(R range, Size size, H const &hf, A const &alloc)
: KeysetImpl(range, size, hf, C(), alloc) {} : KeysetImpl(range, size, hf, C(), alloc) {}
KeysetImpl(InitializerList<Value> init, Size size = 0, KeysetImpl(InitializerList<Value> init, Size size = 0,
const H &hf = H(), const C &eqf = C(), const A &alloc = A() H const &hf = H(), C const &eqf = C(), A const &alloc = A()
): KeysetImpl(iter(init), size, hf, eqf, alloc) {} ): KeysetImpl(iter(init), size, hf, eqf, alloc) {}
KeysetImpl(InitializerList<Value> init, Size size, const A &alloc) KeysetImpl(InitializerList<Value> init, Size size, A const &alloc)
: KeysetImpl(iter(init), size, H(), C(), alloc) {} : KeysetImpl(iter(init), size, H(), C(), alloc) {}
KeysetImpl(InitializerList<Value> init, Size size, const H &hf, KeysetImpl(InitializerList<Value> init, Size size, H const &hf,
const A &alloc A const &alloc
): KeysetImpl(iter(init), size, hf, C(), alloc) {} ): KeysetImpl(iter(init), size, hf, C(), alloc) {}
KeysetImpl &operator=(const KeysetImpl &m) { KeysetImpl &operator=(KeysetImpl const &m) {
Base::operator=(m); Base::operator=(m);
return *this; return *this;
} }
@ -137,16 +137,16 @@ namespace detail {
return *this; return *this;
} }
T *at(const Key &key) { T *at(Key const &key) {
static_assert(!IsMultihash, "at() only allowed on regular keysets"); static_assert(!IsMultihash, "at() only allowed on regular keysets");
return Base::access(key); return Base::access(key);
} }
const T *at(const Key &key) const { T const *at(Key const &key) const {
static_assert(!IsMultihash, "at() only allowed on regular keysets"); static_assert(!IsMultihash, "at() only allowed on regular keysets");
return Base::access(key); return Base::access(key);
} }
T &operator[](const Key &key) { T &operator[](Key const &key) {
static_assert(!IsMultihash, "operator[] only allowed on regular keysets"); static_assert(!IsMultihash, "operator[] only allowed on regular keysets");
return Base::access_or_insert(key); return Base::access_or_insert(key);
} }

62
ostd/map.hh
View File

@ -18,9 +18,9 @@ namespace ostd {
namespace detail { namespace detail {
template<typename K, typename T, typename A> struct MapBase { template<typename K, typename T, typename A> struct MapBase {
using Element = Pair<const K, T>; using Element = Pair<K const, T>;
static inline const K &get_key(Element &e) { static inline K const &get_key(Element &e) {
return e.first; return e.first;
} }
static inline T &get_data(Element &e) { static inline T &get_data(Element &e) {
@ -41,11 +41,11 @@ namespace detail {
typename K, typename T, typename H, typename K, typename T, typename H,
typename C, typename A, bool IsMultihash typename C, typename A, bool IsMultihash
> struct MapImpl: detail::Hashtable<detail::MapBase<K, T, A>, > struct MapImpl: detail::Hashtable<detail::MapBase<K, T, A>,
Pair<const K, T>, K, T, H, C, A, IsMultihash Pair<K const, T>, K, T, H, C, A, IsMultihash
> { > {
private: private:
using Base = detail::Hashtable<detail::MapBase<K, T, A>, using Base = detail::Hashtable<detail::MapBase<K, T, A>,
Pair<const K, T>, K, T, H, C, A, IsMultihash Pair<K const, T>, K, T, H, C, A, IsMultihash
>; >;
public: public:
@ -55,40 +55,40 @@ namespace detail {
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Hasher = H; using Hasher = H;
using KeyEqual = C; using KeyEqual = C;
using Value = Pair<const K, T>; using Value = Pair<K const, T>;
using Reference = Value &; using Reference = Value &;
using Pointer = AllocatorPointer<A>; using Pointer = AllocatorPointer<A>;
using ConstPointer = AllocatorConstPointer<A>; using ConstPointer = AllocatorConstPointer<A>;
using Range = HashRange<Pair<const K, T>>; using Range = HashRange<Pair<K const, T>>;
using ConstRange = HashRange<const Pair<const K, T>>; using ConstRange = HashRange<Pair<K const, T> const>;
using LocalRange = BucketRange<Pair<const K, T>>; using LocalRange = BucketRange<Pair<K const, T>>;
using ConstLocalRange = BucketRange<const Pair<const K, T>>; using ConstLocalRange = BucketRange<Pair<K const, T> const>;
using Allocator = A; using Allocator = A;
explicit MapImpl(Size size, const H &hf = H(), explicit MapImpl(Size size, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size, hf, eqf, alloc) {} ): Base(size, hf, eqf, alloc) {}
MapImpl(): MapImpl(0) {} MapImpl(): MapImpl(0) {}
explicit MapImpl(const A &alloc): MapImpl(0, H(), C(), alloc) {} explicit MapImpl(A const &alloc): MapImpl(0, H(), C(), alloc) {}
MapImpl(Size size, const A &alloc): MapImpl(Size size, A const &alloc):
MapImpl(size, H(), C(), alloc) {} MapImpl(size, H(), C(), alloc) {}
MapImpl(Size size, const H &hf, const A &alloc): MapImpl(Size size, H const &hf, A const &alloc):
MapImpl(size, hf, C(), alloc) {} MapImpl(size, hf, C(), alloc) {}
MapImpl(const MapImpl &m): Base(m, MapImpl(MapImpl const &m): Base(m,
allocator_container_copy(m.get_alloc())) {} allocator_container_copy(m.get_alloc())) {}
MapImpl(const MapImpl &m, const A &alloc): Base(m, alloc) {} MapImpl(MapImpl const &m, A const &alloc): Base(m, alloc) {}
MapImpl(MapImpl &&m): Base(move(m)) {} MapImpl(MapImpl &&m): Base(move(m)) {}
MapImpl(MapImpl &&m, const A &alloc): Base(move(m), alloc) {} MapImpl(MapImpl &&m, A const &alloc): Base(move(m), alloc) {}
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> MapImpl(R range, Size size = 0, const H &hf = H(), >> MapImpl(R range, Size size = 0, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size ? size : detail::estimate_hrsize(range), ): Base(size ? size : detail::estimate_hrsize(range),
hf, eqf, alloc) { hf, eqf, alloc) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
@ -97,25 +97,25 @@ namespace detail {
} }
template<typename R> template<typename R>
MapImpl(R range, Size size, const A &alloc) MapImpl(R range, Size size, A const &alloc)
: MapImpl(range, size, H(), C(), alloc) {} : MapImpl(range, size, H(), C(), alloc) {}
template<typename R> template<typename R>
MapImpl(R range, Size size, const H &hf, const A &alloc) MapImpl(R range, Size size, H const &hf, A const &alloc)
: MapImpl(range, size, hf, C(), alloc) {} : MapImpl(range, size, hf, C(), alloc) {}
MapImpl(InitializerList<Value> init, Size size = 0, MapImpl(InitializerList<Value> init, Size size = 0,
const H &hf = H(), const C &eqf = C(), const A &alloc = A() H const &hf = H(), C const &eqf = C(), A const &alloc = A()
): MapImpl(iter(init), size, hf, eqf, alloc) {} ): MapImpl(iter(init), size, hf, eqf, alloc) {}
MapImpl(InitializerList<Value> init, Size size, const A &alloc) MapImpl(InitializerList<Value> init, Size size, A const &alloc)
: MapImpl(iter(init), size, H(), C(), alloc) {} : MapImpl(iter(init), size, H(), C(), alloc) {}
MapImpl(InitializerList<Value> init, Size size, const H &hf, MapImpl(InitializerList<Value> init, Size size, H const &hf,
const A &alloc A const &alloc
): MapImpl(iter(init), size, hf, C(), alloc) {} ): MapImpl(iter(init), size, hf, C(), alloc) {}
MapImpl &operator=(const MapImpl &m) { MapImpl &operator=(MapImpl const &m) {
Base::operator=(m); Base::operator=(m);
return *this; return *this;
} }
@ -137,16 +137,16 @@ namespace detail {
return *this; return *this;
} }
T *at(const K &key) { T *at(K const &key) {
static_assert(!IsMultihash, "at() only allowed on regular maps"); static_assert(!IsMultihash, "at() only allowed on regular maps");
return Base::access(key); return Base::access(key);
} }
const T *at(const K &key) const { T const *at(K const &key) const {
static_assert(!IsMultihash, "at() only allowed on regular maps"); static_assert(!IsMultihash, "at() only allowed on regular maps");
return Base::access(key); return Base::access(key);
} }
T &operator[](const K &key) { T &operator[](K const &key) {
static_assert(!IsMultihash, "operator[] only allowed on regular maps"); static_assert(!IsMultihash, "operator[] only allowed on regular maps");
return Base::access_or_insert(key); return Base::access_or_insert(key);
} }
@ -165,14 +165,14 @@ template<
typename K, typename T, typename K, typename T,
typename H = ToHash<K>, typename H = ToHash<K>,
typename C = EqualWithCstr<K>, typename C = EqualWithCstr<K>,
typename A = Allocator<Pair<const K, T>> typename A = Allocator<Pair<K const, T>>
> using Map = detail::MapImpl<K, T, H, C, A, false>; > using Map = detail::MapImpl<K, T, H, C, A, false>;
template< template<
typename K, typename T, typename K, typename T,
typename H = ToHash<K>, typename H = ToHash<K>,
typename C = EqualWithCstr<K>, typename C = EqualWithCstr<K>,
typename A = Allocator<Pair<const K, T>> typename A = Allocator<Pair<K const, T>>
> using Multimap = detail::MapImpl<K, T, H, C, A, true>; > using Multimap = detail::MapImpl<K, T, H, C, A, true>;
} /* namespace ostd */ } /* namespace ostd */

80
ostd/maybe.hh
View File

@ -36,7 +36,7 @@ namespace detail {
constexpr MaybeStorage(): p_null_state('\0') {} constexpr MaybeStorage(): p_null_state('\0') {}
MaybeStorage(const MaybeStorage &v): p_engaged(v.p_engaged) { MaybeStorage(MaybeStorage const &v): p_engaged(v.p_engaged) {
if (p_engaged) ::new(address_of(p_value)) Value(v.p_value); if (p_engaged) ::new(address_of(p_value)) Value(v.p_value);
} }
@ -45,7 +45,7 @@ namespace detail {
::new(address_of(p_value)) Value(move(v.p_value)); ::new(address_of(p_value)) Value(move(v.p_value));
} }
constexpr MaybeStorage(const Value &v): p_value(v), p_engaged(true) {} constexpr MaybeStorage(Value const &v): p_value(v), p_engaged(true) {}
constexpr MaybeStorage(Value &&v): p_value(move(v)), p_engaged(true) {} constexpr MaybeStorage(Value &&v): p_value(move(v)), p_engaged(true) {}
template<typename ...A> constexpr MaybeStorage(InPlace, A &&...args): template<typename ...A> constexpr MaybeStorage(InPlace, A &&...args):
@ -68,7 +68,7 @@ namespace detail {
constexpr MaybeStorage(): p_null_state('\0') {} constexpr MaybeStorage(): p_null_state('\0') {}
MaybeStorage(const MaybeStorage &v): p_engaged(v.p_engaged) { MaybeStorage(MaybeStorage const &v): p_engaged(v.p_engaged) {
if (p_engaged) ::new(address_of(p_value)) Value(v.p_value); if (p_engaged) ::new(address_of(p_value)) Value(v.p_value);
} }
@ -77,7 +77,7 @@ namespace detail {
::new(address_of(p_value)) Value(move(v.p_value)); ::new(address_of(p_value)) Value(move(v.p_value));
} }
constexpr MaybeStorage(const Value &v): p_value(v), p_engaged(true) {} constexpr MaybeStorage(Value const &v): p_value(v), p_engaged(true) {}
constexpr MaybeStorage(Value &&v): constexpr MaybeStorage(Value &&v):
p_value(move(v)), p_engaged(true) {} p_value(move(v)), p_engaged(true) {}
@ -105,10 +105,10 @@ public:
"Initialization of Maybe with a non-destructible object is not allowed."); "Initialization of Maybe with a non-destructible object is not allowed.");
constexpr Maybe() {} constexpr Maybe() {}
Maybe(const Maybe &) = default; Maybe(Maybe const &) = default;
Maybe(Maybe &&) = default; Maybe(Maybe &&) = default;
constexpr Maybe(Nothing) {} constexpr Maybe(Nothing) {}
constexpr Maybe(const Value &v): Base(v) {} constexpr Maybe(Value const &v): Base(v) {}
constexpr Maybe(Value &&v): Base(move(v)) {} constexpr Maybe(Value &&v): Base(move(v)) {}
template<typename ...A, typename = EnableIf<IsConstructible<T, A...>>> template<typename ...A, typename = EnableIf<IsConstructible<T, A...>>>
@ -131,7 +131,7 @@ public:
return *this; return *this;
} }
Maybe &operator=(const Maybe &v) { Maybe &operator=(Maybe const &v) {
if (this->p_engaged == v.p_engaged) { if (this->p_engaged == v.p_engaged) {
if (this->p_engaged) this->p_value = v.p_value; if (this->p_engaged) this->p_value = v.p_value;
} else { } else {
@ -189,7 +189,7 @@ public:
this->p_engaged = true; this->p_engaged = true;
} }
constexpr const Value *operator->() const { constexpr Value const *operator->() const {
return address_of(this->p_value); return address_of(this->p_value);
} }
@ -197,7 +197,7 @@ public:
return address_of(this->p_value); return address_of(this->p_value);
} }
constexpr const Value &operator*() const { constexpr Value const &operator*() const {
return this->p_value; return this->p_value;
} }
@ -207,7 +207,7 @@ public:
constexpr explicit operator bool() const { return this->p_engaged; } constexpr explicit operator bool() const { return this->p_engaged; }
constexpr const Value &value() const { constexpr Value const &value() const {
return this->p_value; return this->p_value;
} }
@ -257,156 +257,156 @@ public:
/* maybe vs maybe */ /* maybe vs maybe */
template<typename T> template<typename T>
inline constexpr bool operator==(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator==(Maybe<T> const &a, Maybe<T> const &b) {
return (bool(a) != bool(b)) ? false : (!bool(a) ? true : (*a == *b)); return (bool(a) != bool(b)) ? false : (!bool(a) ? true : (*a == *b));
} }
template<typename T> template<typename T>
inline constexpr bool operator!=(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator!=(Maybe<T> const &a, Maybe<T> const &b) {
return !(a == b); return !(a == b);
} }
template<typename T> template<typename T>
inline constexpr bool operator<(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator<(Maybe<T> const &a, Maybe<T> const &b) {
return !bool(b) ? false : (!bool(a) ? true : (*a < *b)); return !bool(b) ? false : (!bool(a) ? true : (*a < *b));
} }
template<typename T> template<typename T>
inline constexpr bool operator>(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator>(Maybe<T> const &a, Maybe<T> const &b) {
return b < a; return b < a;
} }
template<typename T> template<typename T>
inline constexpr bool operator<=(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator<=(Maybe<T> const &a, Maybe<T> const &b) {
return !(b < a); return !(b < a);
} }
template<typename T> template<typename T>
inline constexpr bool operator>=(const Maybe<T> &a, const Maybe<T> &b) { inline constexpr bool operator>=(Maybe<T> const &a, Maybe<T> const &b) {
return !(a < b); return !(a < b);
} }
/* maybe vs nothing */ /* maybe vs nothing */
template<typename T> template<typename T>
inline constexpr bool operator==(const Maybe<T> &v, Nothing) { inline constexpr bool operator==(Maybe<T> const &v, Nothing) {
return !bool(v); return !bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator==(Nothing, const Maybe<T> &v) { inline constexpr bool operator==(Nothing, Maybe<T> const &v) {
return !bool(v); return !bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator!=(const Maybe<T> &v, Nothing) { inline constexpr bool operator!=(Maybe<T> const &v, Nothing) {
return bool(v); return bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator!=(Nothing, const Maybe<T> &v) { inline constexpr bool operator!=(Nothing, Maybe<T> const &v) {
return bool(v); return bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator<(const Maybe<T> &, Nothing) { inline constexpr bool operator<(Maybe<T> const &, Nothing) {
return false; return false;
} }
template<typename T> template<typename T>
inline constexpr bool operator<(Nothing, const Maybe<T> &v) { inline constexpr bool operator<(Nothing, Maybe<T> const &v) {
return bool(v); return bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator<=(const Maybe<T> &v, Nothing) { inline constexpr bool operator<=(Maybe<T> const &v, Nothing) {
return !bool(v); return !bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator<=(Nothing, const Maybe<T> &) { inline constexpr bool operator<=(Nothing, Maybe<T> const &) {
return true; return true;
} }
template<typename T> template<typename T>
inline constexpr bool operator>(const Maybe<T> &v, Nothing) { inline constexpr bool operator>(Maybe<T> const &v, Nothing) {
return bool(v); return bool(v);
} }
template<typename T> template<typename T>
inline constexpr bool operator>(Nothing, const Maybe<T> &) { inline constexpr bool operator>(Nothing, Maybe<T> const &) {
return false; return false;
} }
template<typename T> template<typename T>
inline constexpr bool operator>=(const Maybe<T> &, Nothing) { inline constexpr bool operator>=(Maybe<T> const &, Nothing) {
return true; return true;
} }
template<typename T> template<typename T>
inline constexpr bool operator>=(Nothing, const Maybe<T> &v) { inline constexpr bool operator>=(Nothing, Maybe<T> const &v) {
return !bool(v); return !bool(v);
} }
/* maybe vs T */ /* maybe vs T */
template<typename T> template<typename T>
inline constexpr bool operator==(const Maybe<T> &a, const T &b) { inline constexpr bool operator==(Maybe<T> const &a, T const &b) {
return bool(a) ? (*a == b) : false; return bool(a) ? (*a == b) : false;
} }
template<typename T> template<typename T>
inline constexpr bool operator==(const T &b, const Maybe<T> &a) { inline constexpr bool operator==(T const &b, Maybe<T> const &a) {
return bool(a) ? (*a == b) : false; return bool(a) ? (*a == b) : false;
} }
template<typename T> template<typename T>
inline constexpr bool operator!=(const Maybe<T> &a, const T &b) { inline constexpr bool operator!=(Maybe<T> const &a, T const &b) {
return bool(a) ? !(*a == b) : true; return bool(a) ? !(*a == b) : true;
} }
template<typename T> template<typename T>
inline constexpr bool operator!=(const T &b, const Maybe<T> &a) { inline constexpr bool operator!=(T const &b, Maybe<T> const &a) {
return bool(a) ? !(*a == b) : true; return bool(a) ? !(*a == b) : true;
} }
template<typename T> template<typename T>
inline constexpr bool operator<(const Maybe<T> &a, const T &b) { inline constexpr bool operator<(Maybe<T> const &a, T const &b) {
return bool(a) ? Less<T>()(*a, b) : true; return bool(a) ? Less<T>()(*a, b) : true;
} }
template<typename T> template<typename T>
inline constexpr bool operator<(const T &b, const Maybe<T> &a) { inline constexpr bool operator<(T const &b, Maybe<T> const &a) {
return bool(a) ? Less<T>()(b, *a) : false; return bool(a) ? Less<T>()(b, *a) : false;
} }
template<typename T> template<typename T>
inline constexpr bool operator<=(const Maybe<T> &a, const T &b) { inline constexpr bool operator<=(Maybe<T> const &a, T const &b) {
return !(a > b); return !(a > b);
} }
template<typename T> template<typename T>
inline constexpr bool operator<=(const T &b, const Maybe<T> &a) { inline constexpr bool operator<=(T const &b, Maybe<T> const &a) {
return !(b > a); return !(b > a);
} }
template<typename T> template<typename T>
inline constexpr bool operator>(const Maybe<T> &a, const T &b) { inline constexpr bool operator>(Maybe<T> const &a, T const &b) {
return bool(a) ? (b < a) : true; return bool(a) ? (b < a) : true;
} }
template<typename T> template<typename T>
inline constexpr bool operator>(const T &b, const Maybe<T> &a) { inline constexpr bool operator>(T const &b, Maybe<T> const &a) {
return bool(a) ? (a < b) : true; return bool(a) ? (a < b) : true;
} }
template<typename T> template<typename T>
inline constexpr bool operator>=(const Maybe<T> &a, const T &b) { inline constexpr bool operator>=(Maybe<T> const &a, T const &b) {
return !(a < b); return !(a < b);
} }
template<typename T> template<typename T>
inline constexpr bool operator>=(const T &b, const Maybe<T> &a) { inline constexpr bool operator>=(T const &b, Maybe<T> const &a) {
return !(b < a); return !(b < a);
} }

80
ostd/memory.hh
View File

@ -17,7 +17,7 @@ namespace ostd {
template<typename T> constexpr T *address_of(T &v) { template<typename T> constexpr T *address_of(T &v) {
return reinterpret_cast<T *>(&const_cast<char &> return reinterpret_cast<T *>(&const_cast<char &>
(reinterpret_cast<const volatile char &>(v))); (reinterpret_cast<char const volatile &>(v)));
} }
/* pointer traits */ /* pointer traits */
@ -181,7 +181,7 @@ template<typename T>
struct DefaultDelete { struct DefaultDelete {
constexpr DefaultDelete() = default; constexpr DefaultDelete() = default;
template<typename U> DefaultDelete(const DefaultDelete<U> &) {}; template<typename U> DefaultDelete(DefaultDelete<U> const &) {};
void operator()(T *p) const { void operator()(T *p) const {
delete p; delete p;
@ -192,7 +192,7 @@ template<typename T>
struct DefaultDelete<T[]> { struct DefaultDelete<T[]> {
constexpr DefaultDelete() = default; constexpr DefaultDelete() = default;
template<typename U> DefaultDelete(const DefaultDelete<U[]> &) {}; template<typename U> DefaultDelete(DefaultDelete<U[]> const &) {};
void operator()(T *p) const { void operator()(T *p) const {
delete[] p; delete[] p;
@ -234,7 +234,7 @@ private:
struct Nat { int x; }; struct Nat { int x; };
using Dref = RemoveReference<D> &; using Dref = RemoveReference<D> &;
using Dcref = const RemoveReference<D> &; using Dcref = RemoveReference<D> const &;
public: public:
constexpr Box(): p_stor(nullptr, D()) { constexpr Box(): p_stor(nullptr, D()) {
@ -248,7 +248,7 @@ public:
static_assert(!IsPointer<D>, "Box constructed with null fptr deleter"); static_assert(!IsPointer<D>, "Box constructed with null fptr deleter");
} }
Box(Pointer p, Conditional<IsReference<D>, D, AddLvalueReference<const D>> d): Box(Pointer p, Conditional<IsReference<D>, D, AddLvalueReference<D const>> d):
p_stor(p, d) {} p_stor(p, d) {}
Box(Pointer p, RemoveReference<D> &&d): Box(Pointer p, RemoveReference<D> &&d):
@ -347,7 +347,7 @@ private:
struct Nat { int x; }; struct Nat { int x; };
using Dref = RemoveReference<D> &; using Dref = RemoveReference<D> &;
using Dcref = const RemoveReference<D> &; using Dcref = RemoveReference<D> const &;
public: public:
constexpr Box(): p_stor(nullptr, D()) { constexpr Box(): p_stor(nullptr, D()) {
@ -364,11 +364,11 @@ public:
} }
template<typename U> Box(U p, Conditional< template<typename U> Box(U p, Conditional<
IsReference<D>, D, AddLvalueReference<const D> IsReference<D>, D, AddLvalueReference<D const>
> d, EnableIf<detail::SameOrLessCvQualified<U, Pointer>, Nat> = Nat()): > d, EnableIf<detail::SameOrLessCvQualified<U, Pointer>, Nat> = Nat()):
p_stor(p, d) {} p_stor(p, d) {}
Box(Nullptr, Conditional<IsReference<D>, D, AddLvalueReference<const D>> d): Box(Nullptr, Conditional<IsReference<D>, D, AddLvalueReference<D const>> d):
p_stor(nullptr, d) {} p_stor(nullptr, d) {}
template<typename U> Box(U p, RemoveReference<D> &&d, template<typename U> Box(U p, RemoveReference<D> &&d,
@ -495,15 +495,15 @@ template<typename> struct Allocator;
template<> struct Allocator<void> { template<> struct Allocator<void> {
using Value = void; using Value = void;
using Pointer = void *; using Pointer = void *;
using ConstPointer = const void *; using ConstPointer = void const *;
template<typename U> using Rebind = Allocator<U>; template<typename U> using Rebind = Allocator<U>;
}; };
template<> struct Allocator<const void> { template<> struct Allocator<void const> {
using Value = const void; using Value = void const;
using Pointer = const void *; using Pointer = void const *;
using ConstPointer = const void *; using ConstPointer = void const *;
template<typename U> using Rebind = Allocator<U>; template<typename U> using Rebind = Allocator<U>;
}; };
@ -513,14 +513,14 @@ template<typename T> struct Allocator {
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Value = T; using Value = T;
using Reference = T &; using Reference = T &;
using ConstReference = const T &; using ConstReference = T const &;
using Pointer = T *; using Pointer = T *;
using ConstPointer = const T *; using ConstPointer = T const *;
template<typename U> using Rebind = Allocator<U>; template<typename U> using Rebind = Allocator<U>;
Allocator() {} Allocator() {}
template<typename U> Allocator(const Allocator<U> &) {} template<typename U> Allocator(Allocator<U> const &) {}
Pointer address(Reference v) const { Pointer address(Reference v) const {
return address_of(v); return address_of(v);
@ -545,19 +545,19 @@ template<typename T> struct Allocator {
void destroy(Pointer p) { p->~T(); } void destroy(Pointer p) { p->~T(); }
}; };
template<typename T> struct Allocator<const T> { template<typename T> struct Allocator<T const> {
using Size = ostd::Size; using Size = ostd::Size;
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Value = const T; using Value = T const;
using Reference = const T &; using Reference = T const &;
using ConstReference = const T &; using ConstReference = T const &;
using Pointer = const T *; using Pointer = T const *;
using ConstPointer = const T *; using ConstPointer = T const *;
template<typename U> using Rebind = Allocator<U>; template<typename U> using Rebind = Allocator<U>;
Allocator() {} Allocator() {}
template<typename U> Allocator(const Allocator<U> &) {} template<typename U> Allocator(Allocator<U> const &) {}
ConstPointer address(ConstReference v) const { ConstPointer address(ConstReference v) const {
return address_of(v); return address_of(v);
@ -580,12 +580,12 @@ template<typename T> struct Allocator<const T> {
}; };
template<typename T, typename U> template<typename T, typename U>
bool operator==(const Allocator<T> &, const Allocator<U> &) { bool operator==(Allocator<T> const &, Allocator<U> const &) {
return true; return true;
} }
template<typename T, typename U> template<typename T, typename U>
bool operator!=(const Allocator<T> &, const Allocator<U> &) { bool operator!=(Allocator<T> const &, Allocator<U> const &) {
return false; return false;
} }
@ -608,7 +608,7 @@ namespace detail {
template<typename T, typename P, typename A> template<typename T, typename P, typename A>
struct ConstPointer<T, P, A, false> { struct ConstPointer<T, P, A, false> {
using Type = PointerRebind<P, const T>; using Type = PointerRebind<P, T const>;
}; };
template<typename T> template<typename T>
@ -644,7 +644,7 @@ namespace detail {
template<typename P, typename A> template<typename P, typename A>
struct ConstVoidPointer<P, A, false> { struct ConstVoidPointer<P, A, false> {
using Type = PointerRebind<P, const void>; using Type = PointerRebind<P, void const>;
}; };
template<typename T> template<typename T>
@ -859,7 +859,7 @@ namespace detail {
-> decltype(a.allocate(sz, p), True()); -> decltype(a.allocate(sz, p), True());
template<typename A, typename S, typename CVP> template<typename A, typename S, typename CVP>
auto allocate_hint_test(const A &, S &&, CVP &&) auto allocate_hint_test(A const &, S &&, CVP &&)
-> False; -> False;
template<typename A, typename S, typename CVP> template<typename A, typename S, typename CVP>
@ -910,7 +910,7 @@ namespace detail {
True()); True());
template<typename A, typename T, typename ...Args> template<typename A, typename T, typename ...Args>
auto construct_test(const A &, T *, Args &&...) auto construct_test(A const &, T *, Args &&...)
-> False; -> False;
template<typename A, typename T, typename ...Args> template<typename A, typename T, typename ...Args>
@ -944,7 +944,7 @@ namespace detail {
auto destroy_test(A &&a, P &&p) -> decltype(a.destroy(p), True()); auto destroy_test(A &&a, P &&p) -> decltype(a.destroy(p), True());
template<typename A, typename P> template<typename A, typename P>
auto destroy_test(const A &, P &&) -> False; auto destroy_test(A const &, P &&) -> False;
template<typename A, typename P> template<typename A, typename P>
constexpr bool DestroyTest constexpr bool DestroyTest
@ -973,27 +973,27 @@ namespace detail {
auto alloc_max_size_test(A &&a) -> decltype(a.max_size(), True()); auto alloc_max_size_test(A &&a) -> decltype(a.max_size(), True());
template<typename A> template<typename A>
auto alloc_max_size_test(const A &) -> False; auto alloc_max_size_test(A const &) -> False;
template<typename A> template<typename A>
constexpr bool AllocMaxSizeTest constexpr bool AllocMaxSizeTest
= IsSame<decltype(alloc_max_size_test(declval<A &>())), True>; = IsSame<decltype(alloc_max_size_test(declval<A &>())), True>;
template<typename A> template<typename A>
inline AllocatorSize<A> alloc_max_size(True, const A &a) { inline AllocatorSize<A> alloc_max_size(True, A const &a) {
return a.max_size(); return a.max_size();
} }
template<typename A> template<typename A>
inline AllocatorSize<A> alloc_max_size(False, const A &) { inline AllocatorSize<A> alloc_max_size(False, A const &) {
return AllocatorSize<A>(~0); return AllocatorSize<A>(~0);
} }
} /* namespace detail */ } /* namespace detail */
template<typename A> template<typename A>
inline AllocatorSize<A> allocator_max_size(const A &a) { inline AllocatorSize<A> allocator_max_size(A const &a) {
return detail::alloc_max_size(BoolConstant< return detail::alloc_max_size(BoolConstant<
detail::AllocMaxSizeTest<const A> detail::AllocMaxSizeTest<A const>
>(), a); >(), a);
} }
@ -1004,27 +1004,27 @@ namespace detail {
auto alloc_copy_test(A &&a) -> decltype(a.container_copy(), True()); auto alloc_copy_test(A &&a) -> decltype(a.container_copy(), True());
template<typename A> template<typename A>
auto alloc_copy_test(const A &) -> False; auto alloc_copy_test(A const &) -> False;
template<typename A> template<typename A>
constexpr bool AllocCopyTest constexpr bool AllocCopyTest
= IsSame<decltype(alloc_copy_test(declval<A &>())), True>; = IsSame<decltype(alloc_copy_test(declval<A &>())), True>;
template<typename A> template<typename A>
inline AllocatorType<A> alloc_container_copy(True, const A &a) { inline AllocatorType<A> alloc_container_copy(True, A const &a) {
return a.container_copy(); return a.container_copy();
} }
template<typename A> template<typename A>
inline AllocatorType<A> alloc_container_copy(False, const A &a) { inline AllocatorType<A> alloc_container_copy(False, A const &a) {
return a; return a;
} }
} /* namespace detail */ } /* namespace detail */
template<typename A> template<typename A>
inline AllocatorType<A> allocator_container_copy(const A &a) { inline AllocatorType<A> allocator_container_copy(A const &a) {
return detail::alloc_container_copy(BoolConstant< return detail::alloc_container_copy(BoolConstant<
detail::AllocCopyTest<const A> detail::AllocCopyTest<A const>
>(), a); >(), a);
} }

198
ostd/range.hh
View File

@ -186,9 +186,9 @@ namespace detail {
template<typename T> constexpr bool IsOutputRangeCore template<typename T> constexpr bool IsOutputRangeCore
= IsConvertible<RangeCategory<T>, OutputRangeTag> || = IsConvertible<RangeCategory<T>, OutputRangeTag> ||
(IsInputRange<T> && (IsInputRange<T> &&
(detail::OutputRangeTest<T, const RangeValue<T> &>::value || (detail::OutputRangeTest<T, RangeValue<T> const &>::value ||
detail::OutputRangeTest<T, RangeValue<T> &&>::value || detail::OutputRangeTest<T, RangeValue<T> &&>::value ||
detail::OutputRangeTest<T, RangeValue<T> >::value)); detail::OutputRangeTest<T, RangeValue<T> >::value));
template<typename T, bool = detail::IsRangeTest<T>> template<typename T, bool = detail::IsRangeTest<T>>
constexpr bool IsOutputRangeBase = false; constexpr bool IsOutputRangeBase = false;
@ -205,7 +205,7 @@ namespace detail {
template<typename T> template<typename T>
struct RangeIterator { struct RangeIterator {
RangeIterator(): p_range() {} RangeIterator(): p_range() {}
explicit RangeIterator(const T &range) { explicit RangeIterator(T const &range) {
::new(&get_ref()) T(range); ::new(&get_ref()) T(range);
} }
explicit RangeIterator(T &&range) { explicit RangeIterator(T &&range) {
@ -221,7 +221,7 @@ namespace detail {
bool operator!=(RangeIterator) const { return !get_ref().empty(); } bool operator!=(RangeIterator) const { return !get_ref().empty(); }
private: private:
T &get_ref() { return *((T *)&p_range); } T &get_ref() { return *((T *)&p_range); }
const T &get_ref() const { return *((T *)&p_range); } T const &get_ref() const { return *((T *)&p_range); }
AlignedStorage<sizeof(T), alignof(T)> p_range; AlignedStorage<sizeof(T), alignof(T)> p_range;
}; };
} }
@ -271,15 +271,15 @@ public:
using Range = T; using Range = T;
RangeHalf() = delete; RangeHalf() = delete;
RangeHalf(const T &range): p_range(range) {} RangeHalf(T const &range): p_range(range) {}
template<typename U, typename = EnableIf<IsConvertible<U, T>>> template<typename U, typename = EnableIf<IsConvertible<U, T>>>
RangeHalf(const RangeHalf<U> &half): p_range(half.p_range) {} RangeHalf(RangeHalf<U> const &half): p_range(half.p_range) {}
RangeHalf(const RangeHalf &half): p_range(half.p_range) {} RangeHalf(RangeHalf const &half): p_range(half.p_range) {}
RangeHalf(RangeHalf &&half): p_range(move(half.p_range)) {} RangeHalf(RangeHalf &&half): p_range(move(half.p_range)) {}
RangeHalf &operator=(const RangeHalf &half) { RangeHalf &operator=(RangeHalf const &half) {
p_range = half.p_range; p_range = half.p_range;
return *this; return *this;
} }
@ -310,18 +310,18 @@ public:
return p_range.front(); return p_range.front();
} }
RangeDifference<T> distance(const RangeHalf &half) const { RangeDifference<T> distance(RangeHalf const &half) const {
return p_range.distance_front(half.p_range); return p_range.distance_front(half.p_range);
} }
bool equals(const RangeHalf &half) const { bool equals(RangeHalf const &half) const {
return p_range.equals_front(half.p_range); return p_range.equals_front(half.p_range);
} }
bool operator==(const RangeHalf &half) const { bool operator==(RangeHalf const &half) const {
return equals(half); return equals(half);
} }
bool operator!=(const RangeHalf &half) const { bool operator!=(RangeHalf const &half) const {
return !equals(half); return !equals(half);
} }
@ -377,16 +377,16 @@ public:
T iter() const { return p_range; } T iter() const { return p_range; }
HalfRange<RangeHalf> iter(const RangeHalf &other) const { HalfRange<RangeHalf> iter(RangeHalf const &other) const {
return HalfRange<RangeHalf>(*this, other); return HalfRange<RangeHalf>(*this, other);
} }
RangeValue<T> *data() { return p_range.data(); } RangeValue<T> *data() { return p_range.data(); }
const RangeValue<T> *data() const { return p_range.data(); } RangeValue<T> const *data() const { return p_range.data(); }
}; };
template<typename R> template<typename R>
inline RangeDifference<R> operator-(const R &lhs, const R &rhs) { inline RangeDifference<R> operator-(R const &lhs, R const &rhs) {
return rhs.distance(lhs); return rhs.distance(lhs);
} }
@ -438,7 +438,7 @@ template<typename B, typename C, typename V, typename R = V &,
using Reference = R; using Reference = R;
detail::RangeIterator<B> begin() const { detail::RangeIterator<B> begin() const {
return detail::RangeIterator<B>((const B &)*this); return detail::RangeIterator<B>((B const &)*this);
} }
detail::RangeIterator<B> end() const { detail::RangeIterator<B> end() const {
return detail::RangeIterator<B>(); return detail::RangeIterator<B>();
@ -498,7 +498,7 @@ template<typename B, typename C, typename V, typename R = V &,
return RangeHalf<B>(iter()); return RangeHalf<B>(iter());
} }
Size put_n(const Value *p, Size n) { Size put_n(Value const *p, Size n) {
B &r = *((B *)this); B &r = *((B *)this);
Size on = n; Size on = n;
for (; n && r.put(*p++); --n); for (; n && r.put(*p++); --n);
@ -539,7 +539,7 @@ template<typename B, typename C, typename V, typename R = V &,
return *((B *)this); return *((B *)this);
} }
B operator++(int) { B operator++(int) {
B tmp(*((const B *)this)); B tmp(*((B const *)this));
((B *)this)->pop_front(); ((B *)this)->pop_front();
return tmp; return tmp;
} }
@ -549,18 +549,18 @@ template<typename B, typename C, typename V, typename R = V &,
return *((B *)this); return *((B *)this);
} }
B operator--(int) { B operator--(int) {
B tmp(*((const B *)this)); B tmp(*((B const *)this));
((B *)this)->push_front(); ((B *)this)->push_front();
return tmp; return tmp;
} }
B operator+(Difference n) const { B operator+(Difference n) const {
B tmp(*((const B *)this)); B tmp(*((B const *)this));
tmp.pop_front_n(n); tmp.pop_front_n(n);
return tmp; return tmp;
} }
B operator-(Difference n) const { B operator-(Difference n) const {
B tmp(*((const B *)this)); B tmp(*((B const *)this));
tmp.push_front_n(n); tmp.push_front_n(n);
return tmp; return tmp;
} }
@ -658,12 +658,12 @@ inline auto iter(T &r) -> decltype(r.iter()) {
} }
template<typename T> template<typename T>
inline auto iter(const T &r) -> decltype(r.iter()) { inline auto iter(T const &r) -> decltype(r.iter()) {
return r.iter(); return r.iter();
} }
template<typename T> template<typename T>
inline auto citer(const T &r) -> decltype(r.iter()) { inline auto citer(T const &r) -> decltype(r.iter()) {
return r.iter(); return r.iter();
} }
@ -676,7 +676,7 @@ template<typename B, typename V, typename R = V &,
using Value = V; using Value = V;
using Reference = R; using Reference = R;
Size put_n(const Value *p, Size n) { Size put_n(Value const *p, Size n) {
B &r = *((B *)this); B &r = *((B *)this);
Size on = n; Size on = n;
for (; n && r.put(*p++); --n); for (; n && r.put(*p++); --n);
@ -698,16 +698,16 @@ private:
T p_end; T p_end;
public: public:
HalfRange() = delete; HalfRange() = delete;
HalfRange(const HalfRange &range): p_beg(range.p_beg), HalfRange(HalfRange const &range): p_beg(range.p_beg),
p_end(range.p_end) {} p_end(range.p_end) {}
HalfRange(HalfRange &&range): p_beg(move(range.p_beg)), HalfRange(HalfRange &&range): p_beg(move(range.p_beg)),
p_end(move(range.p_end)) {} p_end(move(range.p_end)) {}
HalfRange(const T &beg, const T &end): p_beg(beg), HalfRange(T const &beg, T const &end): p_beg(beg),
p_end(end) {} p_end(end) {}
HalfRange(T &&beg, T &&end): p_beg(move(beg)), HalfRange(T &&beg, T &&end): p_beg(move(beg)),
p_end(move(end)) {} p_end(move(end)) {}
HalfRange &operator=(const HalfRange &range) { HalfRange &operator=(HalfRange const &range) {
p_beg = range.p_beg; p_beg = range.p_beg;
p_end = range.p_end; p_end = range.p_end;
return *this; return *this;
@ -739,17 +739,17 @@ public:
RangeReference<Rtype> front() const { return *p_beg; } RangeReference<Rtype> front() const { return *p_beg; }
RangeReference<Rtype> back() const { return *(p_end - 1); } RangeReference<Rtype> back() const { return *(p_end - 1); }
bool equals_front(const HalfRange &range) const { bool equals_front(HalfRange const &range) const {
return p_beg == range.p_beg; return p_beg == range.p_beg;
} }
bool equals_back(const HalfRange &range) const { bool equals_back(HalfRange const &range) const {
return p_end == range.p_end; return p_end == range.p_end;
} }
RangeDifference<Rtype> distance_front(const HalfRange &range) const { RangeDifference<Rtype> distance_front(HalfRange const &range) const {
return range.p_beg - p_beg; return range.p_beg - p_beg;
} }
RangeDifference<Rtype> distance_back(const HalfRange &range) const { RangeDifference<Rtype> distance_back(HalfRange const &range) const {
return range.p_end - p_end; return range.p_end - p_end;
} }
@ -764,7 +764,7 @@ public:
return p_beg[idx]; return p_beg[idx];
} }
bool put(const RangeValue<Rtype> &v) { bool put(RangeValue<Rtype> const &v) {
return p_beg.range().put(v); return p_beg.range().put(v);
} }
bool put(RangeValue<Rtype> &&v) { bool put(RangeValue<Rtype> &&v) {
@ -772,7 +772,7 @@ public:
} }
RangeValue<Rtype> *data() { return p_beg.data(); } RangeValue<Rtype> *data() { return p_beg.data(); }
const RangeValue<Rtype> *data() const { return p_beg.data(); } RangeValue<Rtype> const *data() const { return p_beg.data(); }
}; };
template<typename T> template<typename T>
@ -788,11 +788,11 @@ private:
public: public:
ReverseRange() = delete; ReverseRange() = delete;
ReverseRange(const T &range): p_range(range) {} ReverseRange(T const &range): p_range(range) {}
ReverseRange(const ReverseRange &it): p_range(it.p_range) {} ReverseRange(ReverseRange const &it): p_range(it.p_range) {}
ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {} ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {}
ReverseRange &operator=(const ReverseRange &v) { ReverseRange &operator=(ReverseRange const &v) {
p_range = v.p_range; p_range = v.p_range;
return *this; return *this;
} }
@ -800,7 +800,7 @@ public:
p_range = move(v.p_range); p_range = move(v.p_range);
return *this; return *this;
} }
ReverseRange &operator=(const T &v) { ReverseRange &operator=(T const &v) {
p_range = v; p_range = v;
return *this; return *this;
} }
@ -812,17 +812,17 @@ public:
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
Rsize size() const { return p_range.size(); } Rsize size() const { return p_range.size(); }
bool equals_front(const ReverseRange &r) const { bool equals_front(ReverseRange const &r) const {
return p_range.equals_back(r.p_range); return p_range.equals_back(r.p_range);
} }
bool equals_back(const ReverseRange &r) const { bool equals_back(ReverseRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
RangeDifference<T> distance_front(const ReverseRange &r) const { RangeDifference<T> distance_front(ReverseRange const &r) const {
return -p_range.distance_back(r.p_range); return -p_range.distance_back(r.p_range);
} }
RangeDifference<T> distance_back(const ReverseRange &r) const { RangeDifference<T> distance_back(ReverseRange const &r) const {
return -p_range.distance_front(r.p_range); return -p_range.distance_front(r.p_range);
} }
@ -863,11 +863,11 @@ private:
public: public:
MoveRange() = delete; MoveRange() = delete;
MoveRange(const T &range): p_range(range) {} MoveRange(T const &range): p_range(range) {}
MoveRange(const MoveRange &it): p_range(it.p_range) {} MoveRange(MoveRange const &it): p_range(it.p_range) {}
MoveRange(MoveRange &&it): p_range(move(it.p_range)) {} MoveRange(MoveRange &&it): p_range(move(it.p_range)) {}
MoveRange &operator=(const MoveRange &v) { MoveRange &operator=(MoveRange const &v) {
p_range = v.p_range; p_range = v.p_range;
return *this; return *this;
} }
@ -875,7 +875,7 @@ public:
p_range = move(v.p_range); p_range = move(v.p_range);
return *this; return *this;
} }
MoveRange &operator=(const T &v) { MoveRange &operator=(T const &v) {
p_range = v; p_range = v;
return *this; return *this;
} }
@ -887,17 +887,17 @@ public:
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
Rsize size() const { return p_range.size(); } Rsize size() const { return p_range.size(); }
bool equals_front(const MoveRange &r) const { bool equals_front(MoveRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
bool equals_back(const MoveRange &r) const { bool equals_back(MoveRange const &r) const {
return p_range.equals_back(r.p_range); return p_range.equals_back(r.p_range);
} }
RangeDifference<T> distance_front(const MoveRange &r) const { RangeDifference<T> distance_front(MoveRange const &r) const {
return p_range.distance_front(r.p_range); return p_range.distance_front(r.p_range);
} }
RangeDifference<T> distance_back(const MoveRange &r) const { RangeDifference<T> distance_back(MoveRange const &r) const {
return p_range.distance_back(r.p_range); return p_range.distance_back(r.p_range);
} }
@ -922,14 +922,14 @@ public:
return MoveRange<T>(p_range.slice(start, end)); return MoveRange<T>(p_range.slice(start, end));
} }
bool put(const Rval &v) { return p_range.put(v); } bool put(Rval const &v) { return p_range.put(v); }
bool put(Rval &&v) { return p_range.put(move(v)); } bool put(Rval &&v) { return p_range.put(move(v)); }
}; };
template<typename T> template<typename T>
struct NumberRange: InputRange<NumberRange<T>, ForwardRangeTag, T, T> { struct NumberRange: InputRange<NumberRange<T>, ForwardRangeTag, T, T> {
NumberRange() = delete; NumberRange() = delete;
NumberRange(const NumberRange &it): p_a(it.p_a), p_b(it.p_b), NumberRange(NumberRange const &it): p_a(it.p_a), p_b(it.p_b),
p_step(it.p_step) {} p_step(it.p_step) {}
NumberRange(T a, T b, T step = T(1)): p_a(a), p_b(b), NumberRange(T a, T b, T step = T(1)): p_a(a), p_b(b),
p_step(step) {} p_step(step) {}
@ -937,7 +937,7 @@ struct NumberRange: InputRange<NumberRange<T>, ForwardRangeTag, T, T> {
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_front(const NumberRange &range) const { bool equals_front(NumberRange const &range) const {
return p_a == range.p_a; return p_a == range.p_a;
} }
@ -974,9 +974,9 @@ public:
PointerRange(T *beg, Size n): p_beg(beg), p_end(beg + n) {} PointerRange(T *beg, Size n): p_beg(beg), p_end(beg + n) {}
template<typename U, typename = EnableIf<IsConvertible<U *, T *>>> template<typename U, typename = EnableIf<IsConvertible<U *, T *>>>
PointerRange(const PointerRange<U> &v): p_beg(&v[0]), p_end(&v[v.size()]) {} PointerRange(PointerRange<U> const &v): p_beg(&v[0]), p_end(&v[v.size()]) {}
PointerRange &operator=(const PointerRange &v) { PointerRange &operator=(PointerRange const &v) {
p_beg = v.p_beg; p_beg = v.p_beg;
p_end = v.p_end; p_end = v.p_end;
return *this; return *this;
@ -1010,11 +1010,11 @@ public:
T &front() const { return *p_beg; } T &front() const { return *p_beg; }
bool equals_front(const PointerRange &range) const { bool equals_front(PointerRange const &range) const {
return p_beg == range.p_beg; return p_beg == range.p_beg;
} }
Ptrdiff distance_front(const PointerRange &range) const { Ptrdiff distance_front(PointerRange const &range) const {
return range.p_beg - p_beg; return range.p_beg - p_beg;
} }
@ -1044,11 +1044,11 @@ public:
T &back() const { return *(p_end - 1); } T &back() const { return *(p_end - 1); }
bool equals_back(const PointerRange &range) const { bool equals_back(PointerRange const &range) const {
return p_end == range.p_end; return p_end == range.p_end;
} }
Ptrdiff distance_back(const PointerRange &range) const { Ptrdiff distance_back(PointerRange const &range) const {
return range.p_end - p_end; return range.p_end - p_end;
} }
@ -1062,7 +1062,7 @@ public:
T &operator[](Size i) const { return p_beg[i]; } T &operator[](Size i) const { return p_beg[i]; }
/* satisfy OutputRange */ /* satisfy OutputRange */
bool put(const T &v) { bool put(T const &v) {
if (empty()) return false; if (empty()) return false;
*(p_beg++) = v; *(p_beg++) = v;
return true; return true;
@ -1073,7 +1073,7 @@ public:
return true; return true;
} }
Size put_n(const T *p, Size n) { Size put_n(T const *p, Size n) {
Size ret = size(); Size ret = size();
if (n < ret) ret = n; if (n < ret) ret = n;
if (IsPod<T>) { if (IsPod<T>) {
@ -1104,7 +1104,7 @@ public:
} }
T *data() { return p_beg; } T *data() { return p_beg; }
const T *data() const { return p_beg; } T const *data() const { return p_beg; }
private: private:
T *p_beg, *p_end; T *p_beg, *p_end;
@ -1116,8 +1116,8 @@ inline PointerRange<T> iter(T (&array)[N]) {
} }
template<typename T, Size N> template<typename T, Size N>
inline PointerRange<const T> iter(const T (&array)[N]) { inline PointerRange<T const> iter(T const (&array)[N]) {
return PointerRange<const T>(array, N); return PointerRange<T const>(array, N);
} }
namespace detail { namespace detail {
@ -1158,15 +1158,15 @@ private:
public: public:
EnumeratedRange() = delete; EnumeratedRange() = delete;
EnumeratedRange(const T &range): p_range(range), p_index(0) {} EnumeratedRange(T const &range): p_range(range), p_index(0) {}
EnumeratedRange(const EnumeratedRange &it): EnumeratedRange(EnumeratedRange const &it):
p_range(it.p_range), p_index(it.p_index) {} p_range(it.p_range), p_index(it.p_index) {}
EnumeratedRange(EnumeratedRange &&it): EnumeratedRange(EnumeratedRange &&it):
p_range(move(it.p_range)), p_index(it.p_index) {} p_range(move(it.p_range)), p_index(it.p_index) {}
EnumeratedRange &operator=(const EnumeratedRange &v) { EnumeratedRange &operator=(EnumeratedRange const &v) {
p_range = v.p_range; p_range = v.p_range;
p_index = v.p_index; p_index = v.p_index;
return *this; return *this;
@ -1176,7 +1176,7 @@ public:
p_index = v.p_index; p_index = v.p_index;
return *this; return *this;
} }
EnumeratedRange &operator=(const T &v) { EnumeratedRange &operator=(T const &v) {
p_range = v; p_range = v;
p_index = 0; p_index = 0;
return *this; return *this;
@ -1189,7 +1189,7 @@ public:
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_front(const EnumeratedRange &r) const { bool equals_front(EnumeratedRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
@ -1222,14 +1222,14 @@ private:
RangeSize<T> p_remaining; RangeSize<T> p_remaining;
public: public:
TakeRange() = delete; TakeRange() = delete;
TakeRange(const T &range, RangeSize<T> rem): p_range(range), TakeRange(T const &range, RangeSize<T> rem): p_range(range),
p_remaining(rem) {} p_remaining(rem) {}
TakeRange(const TakeRange &it): p_range(it.p_range), TakeRange(TakeRange const &it): p_range(it.p_range),
p_remaining(it.p_remaining) {} p_remaining(it.p_remaining) {}
TakeRange(TakeRange &&it): p_range(move(it.p_range)), TakeRange(TakeRange &&it): p_range(move(it.p_range)),
p_remaining(it.p_remaining) {} p_remaining(it.p_remaining) {}
TakeRange &operator=(const TakeRange &v) { TakeRange &operator=(TakeRange const &v) {
p_range = v.p_range; p_remaining = v.p_remaining; return *this; p_range = v.p_range; p_remaining = v.p_remaining; return *this;
} }
TakeRange &operator=(TakeRange &&v) { TakeRange &operator=(TakeRange &&v) {
@ -1256,7 +1256,7 @@ public:
RangeReference<T> front() const { return p_range.front(); } RangeReference<T> front() const { return p_range.front(); }
bool equals_front(const TakeRange &r) const { bool equals_front(TakeRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
}; };
@ -1271,14 +1271,14 @@ private:
RangeSize<T> p_chunksize; RangeSize<T> p_chunksize;
public: public:
ChunksRange() = delete; ChunksRange() = delete;
ChunksRange(const T &range, RangeSize<T> chs): p_range(range), ChunksRange(T const &range, RangeSize<T> chs): p_range(range),
p_chunksize(chs) {} p_chunksize(chs) {}
ChunksRange(const ChunksRange &it): p_range(it.p_range), ChunksRange(ChunksRange const &it): p_range(it.p_range),
p_chunksize(it.p_chunksize) {} p_chunksize(it.p_chunksize) {}
ChunksRange(ChunksRange &&it): p_range(move(it.p_range)), ChunksRange(ChunksRange &&it): p_range(move(it.p_range)),
p_chunksize(it.p_chunksize) {} p_chunksize(it.p_chunksize) {}
ChunksRange &operator=(const ChunksRange &v) { ChunksRange &operator=(ChunksRange const &v) {
p_range = v.p_range; p_chunksize = v.p_chunksize; return *this; p_range = v.p_range; p_chunksize = v.p_chunksize; return *this;
} }
ChunksRange &operator=(ChunksRange &&v) { ChunksRange &operator=(ChunksRange &&v) {
@ -1289,7 +1289,7 @@ public:
bool empty() const { return p_range.empty(); } bool empty() const { return p_range.empty(); }
bool equals_front(const ChunksRange &r) const { bool equals_front(ChunksRange const &r) const {
return p_range.equals_front(r.p_range); return p_range.equals_front(r.p_range);
} }
@ -1305,7 +1305,7 @@ namespace detail {
template<Size I, Size N> template<Size I, Size N>
struct JoinRangeEmpty { struct JoinRangeEmpty {
template<typename T> template<typename T>
static bool empty(const T &tup) { static bool empty(T const &tup) {
if (!ostd::get<I>(tup).empty()) if (!ostd::get<I>(tup).empty())
return false; return false;
return JoinRangeEmpty<I + 1, N>::empty(tup); return JoinRangeEmpty<I + 1, N>::empty(tup);
@ -1315,7 +1315,7 @@ namespace detail {
template<Size N> template<Size N>
struct JoinRangeEmpty<N, N> { struct JoinRangeEmpty<N, N> {
template<typename T> template<typename T>
static bool empty(const T &) { static bool empty(T const &) {
return true; return true;
} }
}; };
@ -1323,7 +1323,7 @@ namespace detail {
template<Size I, Size N> template<Size I, Size N>
struct TupleRangeEqual { struct TupleRangeEqual {
template<typename T> template<typename T>
static bool equal(const T &tup1, const T &tup2) { static bool equal(T const &tup1, T const &tup2) {
if (!ostd::get<I>(tup1).equals_front(ostd::get<I>(tup2))) if (!ostd::get<I>(tup1).equals_front(ostd::get<I>(tup2)))
return false; return false;
return TupleRangeEqual<I + 1, N>::equal(tup1, tup2); return TupleRangeEqual<I + 1, N>::equal(tup1, tup2);
@ -1333,7 +1333,7 @@ namespace detail {
template<Size N> template<Size N>
struct TupleRangeEqual<N, N> { struct TupleRangeEqual<N, N> {
template<typename T> template<typename T>
static bool equal(const T &, const T &) { static bool equal(T const &, T const &) {
return true; return true;
} }
}; };
@ -1360,7 +1360,7 @@ namespace detail {
template<Size I, Size N, typename T> template<Size I, Size N, typename T>
struct JoinRangeFront { struct JoinRangeFront {
template<typename U> template<typename U>
static T front(const U &tup) { static T front(U const &tup) {
if (!ostd::get<I>(tup).empty()) { if (!ostd::get<I>(tup).empty()) {
return ostd::get<I>(tup).front(); return ostd::get<I>(tup).front();
} }
@ -1371,7 +1371,7 @@ namespace detail {
template<Size N, typename T> template<Size N, typename T>
struct JoinRangeFront<N, N, T> { struct JoinRangeFront<N, N, T> {
template<typename U> template<typename U>
static T front(const U &tup) { static T front(U const &tup) {
return ostd::get<0>(tup).front(); return ostd::get<0>(tup).front();
} }
}; };
@ -1386,12 +1386,12 @@ private:
Tuple<R...> p_ranges; Tuple<R...> p_ranges;
public: public:
JoinRange() = delete; JoinRange() = delete;
JoinRange(const R &...ranges): p_ranges(ranges...) {} JoinRange(R const &...ranges): p_ranges(ranges...) {}
JoinRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {} JoinRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {}
JoinRange(const JoinRange &v): p_ranges(v.p_ranges) {} JoinRange(JoinRange const &v): p_ranges(v.p_ranges) {}
JoinRange(JoinRange &&v): p_ranges(move(v.p_ranges)) {} JoinRange(JoinRange &&v): p_ranges(move(v.p_ranges)) {}
JoinRange &operator=(const JoinRange &v) { JoinRange &operator=(JoinRange const &v) {
p_ranges = v.p_ranges; p_ranges = v.p_ranges;
return *this; return *this;
} }
@ -1405,7 +1405,7 @@ public:
return detail::JoinRangeEmpty<0, sizeof...(R)>::empty(p_ranges); return detail::JoinRangeEmpty<0, sizeof...(R)>::empty(p_ranges);
} }
bool equals_front(const JoinRange &r) const { bool equals_front(JoinRange const &r) const {
return detail::TupleRangeEqual<0, sizeof...(R)>::equal(p_ranges, return detail::TupleRangeEqual<0, sizeof...(R)>::equal(p_ranges,
r.p_ranges); r.p_ranges);
} }
@ -1437,7 +1437,7 @@ namespace detail {
template<Size I, Size N> template<Size I, Size N>
struct ZipRangeEmpty { struct ZipRangeEmpty {
template<typename T> template<typename T>
static bool empty(const T &tup) { static bool empty(T const &tup) {
if (ostd::get<I>(tup).empty()) if (ostd::get<I>(tup).empty())
return true; return true;
return ZipRangeEmpty<I + 1, N>::empty(tup); return ZipRangeEmpty<I + 1, N>::empty(tup);
@ -1447,7 +1447,7 @@ namespace detail {
template<Size N> template<Size N>
struct ZipRangeEmpty<N, N> { struct ZipRangeEmpty<N, N> {
template<typename T> template<typename T>
static bool empty(const T &) { static bool empty(T const &) {
return false; return false;
} }
}; };
@ -1472,12 +1472,12 @@ namespace detail {
template<typename ...T> template<typename ...T>
struct ZipRangeFront { struct ZipRangeFront {
template<typename U, Size ...I> template<typename U, Size ...I>
static ZipValue<T...> tup_get(const U &tup, detail::TupleIndices<I...>) { static ZipValue<T...> tup_get(U const &tup, detail::TupleIndices<I...>) {
return ZipValue<T...>(ostd::get<I>(tup).front()...); return ZipValue<T...>(ostd::get<I>(tup).front()...);
} }
template<typename U> template<typename U>
static ZipValue<T...> front(const U &tup) { static ZipValue<T...> front(U const &tup) {
using Index = detail::MakeTupleIndices<sizeof...(T)>; using Index = detail::MakeTupleIndices<sizeof...(T)>;
return ZipRangeFront<T...>::tup_get(tup, Index()); return ZipRangeFront<T...>::tup_get(tup, Index());
} }
@ -1494,12 +1494,12 @@ private:
Tuple<R...> p_ranges; Tuple<R...> p_ranges;
public: public:
ZipRange() = delete; ZipRange() = delete;
ZipRange(const R &...ranges): p_ranges(ranges...) {} ZipRange(R const &...ranges): p_ranges(ranges...) {}
ZipRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {} ZipRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {}
ZipRange(const ZipRange &v): p_ranges(v.p_ranges) {} ZipRange(ZipRange const &v): p_ranges(v.p_ranges) {}
ZipRange(ZipRange &&v): p_ranges(move(v.p_ranges)) {} ZipRange(ZipRange &&v): p_ranges(move(v.p_ranges)) {}
ZipRange &operator=(const ZipRange &v) { ZipRange &operator=(ZipRange const &v) {
p_ranges = v.p_ranges; p_ranges = v.p_ranges;
return *this; return *this;
} }
@ -1513,7 +1513,7 @@ public:
return detail::ZipRangeEmpty<0, sizeof...(R)>::empty(p_ranges); return detail::ZipRangeEmpty<0, sizeof...(R)>::empty(p_ranges);
} }
bool equals_front(const ZipRange &r) const { bool equals_front(ZipRange const &r) const {
return detail::TupleRangeEqual<0, sizeof...(R)>::equal(p_ranges, return detail::TupleRangeEqual<0, sizeof...(R)>::equal(p_ranges,
r.p_ranges); r.p_ranges);
} }
@ -1531,12 +1531,12 @@ template<typename T>
struct AppenderRange: OutputRange<AppenderRange<T>, typename T::Value, struct AppenderRange: OutputRange<AppenderRange<T>, typename T::Value,
typename T::Reference, typename T::Size, typename T::Difference> { typename T::Reference, typename T::Size, typename T::Difference> {
AppenderRange(): p_data() {} AppenderRange(): p_data() {}
AppenderRange(const T &v): p_data(v) {} AppenderRange(T const &v): p_data(v) {}
AppenderRange(T &&v): p_data(move(v)) {} AppenderRange(T &&v): p_data(move(v)) {}
AppenderRange(const AppenderRange &v): p_data(v.p_data) {} AppenderRange(AppenderRange const &v): p_data(v.p_data) {}
AppenderRange(AppenderRange &&v): p_data(move(v.p_data)) {} AppenderRange(AppenderRange &&v): p_data(move(v.p_data)) {}
AppenderRange &operator=(const AppenderRange &v) { AppenderRange &operator=(AppenderRange const &v) {
p_data = v.p_data; p_data = v.p_data;
return *this; return *this;
} }
@ -1546,7 +1546,7 @@ struct AppenderRange: OutputRange<AppenderRange<T>, typename T::Value,
return *this; return *this;
} }
AppenderRange &operator=(const T &v) { AppenderRange &operator=(T const &v) {
p_data = v; p_data = v;
return *this; return *this;
} }

42
ostd/set.hh
View File

@ -18,14 +18,14 @@ namespace ostd {
namespace detail { namespace detail {
template<typename T, typename A> struct SetBase { template<typename T, typename A> struct SetBase {
static inline const T &get_key(const T &e) { static inline T const &get_key(T const &e) {
return e; return e;
} }
static inline T &get_data(T &e) { static inline T &get_data(T &e) {
return e; return e;
} }
template<typename U> template<typename U>
static inline void set_key(T &, const U &, A &) {} static inline void set_key(T &, U const &, A &) {}
static inline void swap_elem(T &a, T &b) { swap_adl(a, b); } static inline void swap_elem(T &a, T &b) { swap_adl(a, b); }
}; };
@ -49,35 +49,35 @@ namespace detail {
using Pointer = AllocatorPointer<A>; using Pointer = AllocatorPointer<A>;
using ConstPointer = AllocatorConstPointer<A>; using ConstPointer = AllocatorConstPointer<A>;
using Range = HashRange<T>; using Range = HashRange<T>;
using ConstRange = HashRange<const T>; using ConstRange = HashRange<T const>;
using LocalRange = BucketRange<T>; using LocalRange = BucketRange<T>;
using ConstLocalRange = BucketRange<const T>; using ConstLocalRange = BucketRange<T const>;
using Allocator = A; using Allocator = A;
explicit SetImpl(Size size, const H &hf = H(), explicit SetImpl(Size size, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size, hf, eqf, alloc) {} ): Base(size, hf, eqf, alloc) {}
SetImpl(): SetImpl(0) {} SetImpl(): SetImpl(0) {}
explicit SetImpl(const A &alloc): SetImpl(0, H(), C(), alloc) {} explicit SetImpl(A const &alloc): SetImpl(0, H(), C(), alloc) {}
SetImpl(Size size, const A &alloc): SetImpl(Size size, A const &alloc):
SetImpl(size, H(), C(), alloc) {} SetImpl(size, H(), C(), alloc) {}
SetImpl(Size size, const H &hf, const A &alloc): SetImpl(Size size, H const &hf, A const &alloc):
SetImpl(size, hf, C(), alloc) {} SetImpl(size, hf, C(), alloc) {}
SetImpl(const SetImpl &m): Base(m, SetImpl(SetImpl const &m): Base(m,
allocator_container_copy(m.get_alloc())) {} allocator_container_copy(m.get_alloc())) {}
SetImpl(const SetImpl &m, const A &alloc): Base(m, alloc) {} SetImpl(SetImpl const &m, A const &alloc): Base(m, alloc) {}
SetImpl(SetImpl &&m): Base(move(m)) {} SetImpl(SetImpl &&m): Base(move(m)) {}
SetImpl(SetImpl &&m, const A &alloc): Base(move(m), alloc) {} SetImpl(SetImpl &&m, A const &alloc): Base(move(m), alloc) {}
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> SetImpl(R range, Size size = 0, const H &hf = H(), >> SetImpl(R range, Size size = 0, H const &hf = H(),
const C &eqf = C(), const A &alloc = A() C const &eqf = C(), A const &alloc = A()
): Base(size ? size : detail::estimate_hrsize(range), ): Base(size ? size : detail::estimate_hrsize(range),
hf, eqf, alloc) { hf, eqf, alloc) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
@ -86,25 +86,25 @@ namespace detail {
} }
template<typename R> template<typename R>
SetImpl(R range, Size size, const A &alloc) SetImpl(R range, Size size, A const &alloc)
: SetImpl(range, size, H(), C(), alloc) {} : SetImpl(range, size, H(), C(), alloc) {}
template<typename R> template<typename R>
SetImpl(R range, Size size, const H &hf, const A &alloc) SetImpl(R range, Size size, H const &hf, A const &alloc)
: SetImpl(range, size, hf, C(), alloc) {} : SetImpl(range, size, hf, C(), alloc) {}
SetImpl(InitializerList<Value> init, Size size = 0, SetImpl(InitializerList<Value> init, Size size = 0,
const H &hf = H(), const C &eqf = C(), const A &alloc = A() H const &hf = H(), C const &eqf = C(), A const &alloc = A()
): SetImpl(iter(init), size, hf, eqf, alloc) {} ): SetImpl(iter(init), size, hf, eqf, alloc) {}
SetImpl(InitializerList<Value> init, Size size, const A &alloc) SetImpl(InitializerList<Value> init, Size size, A const &alloc)
: SetImpl(iter(init), size, H(), C(), alloc) {} : SetImpl(iter(init), size, H(), C(), alloc) {}
SetImpl(InitializerList<Value> init, Size size, const H &hf, SetImpl(InitializerList<Value> init, Size size, H const &hf,
const A &alloc A const &alloc
): SetImpl(iter(init), size, hf, C(), alloc) {} ): SetImpl(iter(init), size, hf, C(), alloc) {}
SetImpl &operator=(const SetImpl &m) { SetImpl &operator=(SetImpl const &m) {
Base::operator=(m); Base::operator=(m);
return *this; return *this;
} }

28
ostd/stream.hh
View File

@ -37,7 +37,7 @@ namespace detail {
template<Size N> template<Size N>
struct FormatOutRange: OutputRange<FormatOutRange<N>, char> { struct FormatOutRange: OutputRange<FormatOutRange<N>, char> {
FormatOutRange(char *ibuf): buf(ibuf), idx(0) {} FormatOutRange(char *ibuf): buf(ibuf), idx(0) {}
FormatOutRange(const FormatOutRange &r): buf(r.buf), idx(r.idx) {} FormatOutRange(FormatOutRange const &r): buf(r.buf), idx(r.idx) {}
char *buf; char *buf;
Size idx; Size idx;
bool put(char v) { bool put(char v) {
@ -68,8 +68,8 @@ private:
} }
template<typename T> template<typename T>
inline bool write_impl(const T &v, EnableIf< inline bool write_impl(T const &v, EnableIf<
!IsConstructible<ConstCharRange, const T &>, StNat !IsConstructible<ConstCharRange, T const &>, StNat
> = StNat()) { > = StNat()) {
return write(ostd::to_string(v)); return write(ostd::to_string(v));
} }
@ -99,7 +99,7 @@ public:
virtual bool flush() { return true; } virtual bool flush() { return true; }
virtual Size read_bytes(void *, Size) { return 0; } virtual Size read_bytes(void *, Size) { return 0; }
virtual Size write_bytes(const void *, Size) { return 0; } virtual Size write_bytes(void const *, Size) { return 0; }
virtual int getchar() { virtual int getchar() {
byte c; byte c;
@ -112,27 +112,27 @@ public:
} }
template<typename T> template<typename T>
bool write(const T &v) { bool write(T const &v) {
return write_impl(v); return write_impl(v);
} }
template<typename T, typename ...A> template<typename T, typename ...A>
bool write(const T &v, const A &...args) { bool write(T const &v, A const &...args) {
return write(v) && write(args...); return write(v) && write(args...);
} }
template<typename T> template<typename T>
bool writeln(const T &v) { bool writeln(T const &v) {
return write(v) && putchar('\n'); return write(v) && putchar('\n');
} }
template<typename T, typename ...A> template<typename T, typename ...A>
bool writeln(const T &v, const A &...args) { bool writeln(T const &v, A const &...args) {
return write(v) && write(args...) && putchar('\n'); return write(v) && write(args...) && putchar('\n');
} }
template<typename ...A> template<typename ...A>
bool writef(ConstCharRange fmt, const A &...args) { bool writef(ConstCharRange fmt, A const &...args) {
char buf[512]; char buf[512];
Ptrdiff need = format(detail::FormatOutRange<sizeof(buf)>(buf), Ptrdiff need = format(detail::FormatOutRange<sizeof(buf)>(buf),
fmt, args...); fmt, args...);
@ -147,14 +147,14 @@ public:
} }
template<typename ...A> template<typename ...A>
bool writefln(ConstCharRange fmt, const A &...args) { bool writefln(ConstCharRange fmt, A const &...args) {
return writef(fmt, args...) && putchar('\n'); return writef(fmt, args...) && putchar('\n');
} }
template<typename T = char> template<typename T = char>
StreamRange<T> iter(); StreamRange<T> iter();
template<typename T> Size put(const T *v, Size count) { template<typename T> Size put(T const *v, Size count) {
return write_bytes(v, count * sizeof(T)) / sizeof(T); return write_bytes(v, count * sizeof(T)) / sizeof(T);
} }
@ -182,7 +182,7 @@ struct StreamRange<T, true>: InputRange<
> { > {
StreamRange() = delete; StreamRange() = delete;
StreamRange(Stream &s): p_stream(&s), p_size(s.size()) {} StreamRange(Stream &s): p_stream(&s), p_size(s.size()) {}
StreamRange(const StreamRange &r): p_stream(r.p_stream), p_size(r.p_size) {} StreamRange(StreamRange const &r): p_stream(r.p_stream), p_size(r.p_size) {}
bool empty() const { bool empty() const {
return (p_size - p_stream->tell()) < StreamOffset(sizeof(T)); return (p_size - p_stream->tell()) < StreamOffset(sizeof(T));
@ -200,7 +200,7 @@ struct StreamRange<T, true>: InputRange<
return val; return val;
} }
bool equals_front(const StreamRange &s) const { bool equals_front(StreamRange const &s) const {
return p_stream->tell() == s.p_stream->tell(); return p_stream->tell() == s.p_stream->tell();
} }
@ -210,7 +210,7 @@ struct StreamRange<T, true>: InputRange<
return (v == sizeof(T)); return (v == sizeof(T));
} }
Size put_n(const T *p, Size n) { Size put_n(T const *p, Size n) {
return p_stream->put(p, n); return p_stream->put(p, n);
} }

136
ostd/string.hh
View File

@ -49,21 +49,21 @@ public:
p_beg(beg), p_end(beg + N - (beg[N - 1] == '\0')) {} p_beg(beg), p_end(beg + N - (beg[N - 1] == '\0')) {}
template<typename U, typename A> template<typename U, typename A>
CharRangeBase(const StringBase<U, A> &s, EnableIf< CharRangeBase(StringBase<U, A> const &s, EnableIf<
IsConvertible<U *, T *>, Nat IsConvertible<U *, T *>, Nat
> = Nat()): p_beg(s.data()), > = Nat()): p_beg(s.data()),
p_end(s.data() + s.size()) {} p_end(s.data() + s.size()) {}
template<typename U, typename = EnableIf<IsConvertible<U *, T *>>> template<typename U, typename = EnableIf<IsConvertible<U *, T *>>>
CharRangeBase(const CharRangeBase<U> &v): CharRangeBase(CharRangeBase<U> const &v):
p_beg(&v[0]), p_end(&v[v.size()]) {} p_beg(&v[0]), p_end(&v[v.size()]) {}
CharRangeBase &operator=(const CharRangeBase &v) { CharRangeBase &operator=(CharRangeBase const &v) {
p_beg = v.p_beg; p_end = v.p_end; return *this; p_beg = v.p_beg; p_end = v.p_end; return *this;
} }
template<typename A> template<typename A>
CharRangeBase &operator=(const StringBase<T, A> &s) { CharRangeBase &operator=(StringBase<T, A> const &s) {
p_beg = s.data(); p_end = s.data() + s.size(); return *this; p_beg = s.data(); p_end = s.data() + s.size(); return *this;
} }
/* TODO: traits for utf-16/utf-32 string lengths, for now assume char */ /* TODO: traits for utf-16/utf-32 string lengths, for now assume char */
@ -94,11 +94,11 @@ public:
T &front() const { return *p_beg; } T &front() const { return *p_beg; }
bool equals_front(const CharRangeBase &range) const { bool equals_front(CharRangeBase const &range) const {
return p_beg == range.p_beg; return p_beg == range.p_beg;
} }
Ptrdiff distance_front(const CharRangeBase &range) const { Ptrdiff distance_front(CharRangeBase const &range) const {
return range.p_beg - p_beg; return range.p_beg - p_beg;
} }
@ -123,11 +123,11 @@ public:
T &back() const { return *(p_end - 1); } T &back() const { return *(p_end - 1); }
bool equals_back(const CharRangeBase &range) const { bool equals_back(CharRangeBase const &range) const {
return p_end == range.p_end; return p_end == range.p_end;
} }
Ptrdiff distance_back(const CharRangeBase &range) const { Ptrdiff distance_back(CharRangeBase const &range) const {
return range.p_end - p_end; return range.p_end - p_end;
} }
@ -145,7 +145,7 @@ public:
return true; return true;
} }
Size put_n(const T *p, Size n) { Size put_n(T const *p, Size n) {
Size an = ostd::min(n, size()); Size an = ostd::min(n, size());
memcpy(p_beg, p, an * sizeof(T)); memcpy(p_beg, p, an * sizeof(T));
p_beg += an; p_beg += an;
@ -153,14 +153,14 @@ public:
} }
T *data() { return p_beg; } T *data() { return p_beg; }
const T *data() const { return p_beg; } T const *data() const { return p_beg; }
Size to_hash() const { Size to_hash() const {
return detail::mem_hash(data(), size()); return detail::mem_hash(data(), size());
} }
/* non-range */ /* non-range */
int compare(CharRangeBase<const T> s) const { int compare(CharRangeBase<T const> s) const {
int ret = memcmp(data(), s.data(), ostd::min(size(), s.size())); int ret = memcmp(data(), s.data(), ostd::min(size(), s.size()));
return ret ? ret : (size() - s.size()); return ret ? ret : (size() - s.size());
} }
@ -181,7 +181,7 @@ private:
}; };
using CharRange = CharRangeBase<char>; using CharRange = CharRangeBase<char>;
using ConstCharRange = CharRangeBase<const char>; using ConstCharRange = CharRangeBase<char const>;
inline bool operator==(ConstCharRange lhs, ConstCharRange rhs) { inline bool operator==(ConstCharRange lhs, ConstCharRange rhs) {
return !lhs.compare(rhs); return !lhs.compare(rhs);
@ -254,17 +254,17 @@ public:
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Value = T; using Value = T;
using Reference = T &; using Reference = T &;
using ConstReference = const T &; using ConstReference = T const &;
using Pointer = AllocatorPointer<A>; using Pointer = AllocatorPointer<A>;
using ConstPointer = AllocatorConstPointer<A>; using ConstPointer = AllocatorConstPointer<A>;
using Range = CharRangeBase<T>; using Range = CharRangeBase<T>;
using ConstRange = CharRangeBase<const T>; using ConstRange = CharRangeBase<T const>;
using Allocator = A; using Allocator = A;
StringBase(const A &a = A()): p_len(0), p_cap(0), StringBase(A const &a = A()): p_len(0), p_cap(0),
p_buf((Pointer)&p_len, a) {} p_buf((Pointer)&p_len, a) {}
explicit StringBase(Size n, T val = T(), const A &al = A()): explicit StringBase(Size n, T val = T(), A const &al = A()):
StringBase(al) { StringBase(al) {
if (!n) return; if (!n) return;
p_buf.first() = allocator_allocate(p_buf.second(), n + 1); p_buf.first() = allocator_allocate(p_buf.second(), n + 1);
@ -274,14 +274,14 @@ public:
*cur = '\0'; *cur = '\0';
} }
StringBase(const StringBase &s): p_len(0), p_cap(0), StringBase(StringBase const &s): p_len(0), p_cap(0),
p_buf((Pointer)&p_len, allocator_container_copy(s.p_buf.second())) { p_buf((Pointer)&p_len, allocator_container_copy(s.p_buf.second())) {
if (!s.p_len) return; if (!s.p_len) return;
reserve(s.p_len); reserve(s.p_len);
p_len = s.p_len; p_len = s.p_len;
memcpy(p_buf.first(), s.p_buf.first(), (p_len + 1) * sizeof(T)); memcpy(p_buf.first(), s.p_buf.first(), (p_len + 1) * sizeof(T));
} }
StringBase(const StringBase &s, const A &a): p_len(0), p_cap(0), StringBase(StringBase const &s, A const &a): p_len(0), p_cap(0),
p_buf((Pointer)&p_len, a) { p_buf((Pointer)&p_len, a) {
if (!s.p_len) return; if (!s.p_len) return;
reserve(s.p_len); reserve(s.p_len);
@ -293,7 +293,7 @@ public:
s.p_len = s.p_cap = 0; s.p_len = s.p_cap = 0;
s.p_buf.first() = (Pointer)&s.p_len; s.p_buf.first() = (Pointer)&s.p_len;
} }
StringBase(StringBase &&s, const A &a): p_len(0), p_cap(0), StringBase(StringBase &&s, A const &a): p_len(0), p_cap(0),
p_buf((Pointer)&p_len, a) { p_buf((Pointer)&p_len, a) {
if (!s.p_len) return; if (!s.p_len) return;
if (a != s.p_buf.second()) { if (a != s.p_buf.second()) {
@ -309,8 +309,8 @@ public:
s.p_buf.first() = &s.p_cap; s.p_buf.first() = &s.p_cap;
} }
StringBase(const StringBase &s, Size pos, Size len = npos, StringBase(StringBase const &s, Size pos, Size len = npos,
const A &a = A()): StringBase(a) { A const &a = A()): StringBase(a) {
Size end = (len == npos) ? s.size() : (pos + len); Size end = (len == npos) ? s.size() : (pos + len);
Size nch = (end - pos); Size nch = (end - pos);
reserve(nch); reserve(nch);
@ -320,7 +320,7 @@ public:
} }
/* TODO: traits for utf-16/utf-32 string lengths, for now assume char */ /* TODO: traits for utf-16/utf-32 string lengths, for now assume char */
StringBase(ConstRange v, const A &a = A()): StringBase(a) { StringBase(ConstRange v, A const &a = A()): StringBase(a) {
if (!v.size()) return; if (!v.size()) return;
reserve(v.size()); reserve(v.size());
memcpy(p_buf.first(), &v[0], v.size()); memcpy(p_buf.first(), &v[0], v.size());
@ -329,18 +329,18 @@ public:
} }
template<typename U> template<typename U>
StringBase(U v, const EnableIf< StringBase(U v, EnableIf<
IsConvertible<U, const Value *> && !IsArray<U>, A IsConvertible<U, Value const *> && !IsArray<U>, A
> &a = A()): StringBase(ConstRange(v), a) {} > const &a = A()): StringBase(ConstRange(v), a) {}
template<typename U, Size N> template<typename U, Size N>
StringBase(U (&v)[N], const EnableIf< StringBase(U (&v)[N], EnableIf<
IsConvertible<U *, const Value *>, A IsConvertible<U *, Value const *>, A
> &a = A()): StringBase(ConstRange(v), a) {} > const &a = A()): StringBase(ConstRange(v), a) {}
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> StringBase(R range, const A &a = A()): StringBase(a) { >> StringBase(R range, A const &a = A()): StringBase(a) {
ctor_from_range(range); ctor_from_range(range);
} }
@ -355,7 +355,7 @@ public:
*p_buf.first() = '\0'; *p_buf.first() = '\0';
} }
StringBase &operator=(const StringBase &v) { StringBase &operator=(StringBase const &v) {
if (this == &v) return *this; if (this == &v) return *this;
clear(); clear();
if (AllocatorPropagateOnContainerCopyAssignment<A>) { if (AllocatorPropagateOnContainerCopyAssignment<A>) {
@ -397,20 +397,20 @@ public:
} }
template<typename U> template<typename U>
EnableIf<IsConvertible<U, const Value *> && !IsArray<U>, StringBase &> EnableIf<IsConvertible<U, Value const *> && !IsArray<U>, StringBase &>
operator=(U v) { operator=(U v) {
return operator=(ConstRange(v)); return operator=(ConstRange(v));
} }
template<typename U, Size N> template<typename U, Size N>
EnableIf<IsConvertible<U *, const Value *>, StringBase &> EnableIf<IsConvertible<U *, Value const *>, StringBase &>
operator=(U (&v)[N]) { operator=(U (&v)[N]) {
return operator=(ConstRange(v)); return operator=(ConstRange(v));
} }
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> StringBase &operator=(const R &r) { >> StringBase &operator=(R const &r) {
clear(); clear();
ctor_from_range(r); ctor_from_range(r);
return *this; return *this;
@ -448,19 +448,19 @@ public:
} }
T &operator[](Size i) { return p_buf.first()[i]; } T &operator[](Size i) { return p_buf.first()[i]; }
const T &operator[](Size i) const { return p_buf.first()[i]; } T const &operator[](Size i) const { return p_buf.first()[i]; }
T &at(Size i) { return p_buf.first()[i]; } T &at(Size i) { return p_buf.first()[i]; }
const T &at(Size i) const { return p_buf.first()[i]; } T const &at(Size i) const { return p_buf.first()[i]; }
T &front() { return p_buf.first()[0]; } T &front() { return p_buf.first()[0]; }
const T &front() const { return p_buf.first()[0]; }; T const &front() const { return p_buf.first()[0]; };
T &back() { return p_buf.first()[size() - 1]; } T &back() { return p_buf.first()[size() - 1]; }
const T &back() const { return p_buf.first()[size() - 1]; } T const &back() const { return p_buf.first()[size() - 1]; }
Value *data() { return p_buf.first(); } Value *data() { return p_buf.first(); }
const Value *data() const { return p_buf.first(); } Value const *data() const { return p_buf.first(); }
Size size() const { Size size() const {
return p_len; return p_len;
@ -531,7 +531,7 @@ public:
return append(1, c); return append(1, c);
} }
template<typename R> template<typename R>
StringBase &operator+=(const R &v) { StringBase &operator+=(R const &v) {
return append(v); return append(v);
} }
@ -575,11 +575,11 @@ using String = StringBase<char>;
/* string literals */ /* string literals */
inline namespace literals { inline namespace string_literals { inline namespace literals { inline namespace string_literals {
inline String operator "" _s(const char *str, Size len) { inline String operator "" _s(char const *str, Size len) {
return String(ConstCharRange(str, len)); return String(ConstCharRange(str, len));
} }
inline ConstCharRange operator "" _S(const char *str, Size len) { inline ConstCharRange operator "" _S(char const *str, Size len) {
return ConstCharRange(str, len); return ConstCharRange(str, len);
} }
} } } }
@ -607,7 +607,7 @@ namespace detail {
} }
template<typename R, typename T, typename F> template<typename R, typename T, typename F>
bool concat(R &&sink, const T &v, ConstCharRange sep, F func) { bool concat(R &&sink, T const &v, ConstCharRange sep, F func) {
auto range = ostd::iter(v); auto range = ostd::iter(v);
if (range.empty()) return true; if (range.empty()) return true;
for (;;) { for (;;) {
@ -623,7 +623,7 @@ bool concat(R &&sink, const T &v, ConstCharRange sep, F func) {
} }
template<typename R, typename T> template<typename R, typename T>
bool concat(R &&sink, const T &v, ConstCharRange sep = " ") { bool concat(R &&sink, T const &v, ConstCharRange sep = " ") {
auto range = ostd::iter(v); auto range = ostd::iter(v);
if (range.empty()) return true; if (range.empty()) return true;
for (;;) { for (;;) {
@ -657,7 +657,7 @@ namespace detail {
p_written += ret; p_written += ret;
return ret; return ret;
} }
Size put_n(const char *v, Size n) { Size put_n(char const *v, Size n) {
Size ret = p_out.put_n(v, n); Size ret = p_out.put_n(v, n);
p_written += ret; p_written += ret;
return ret; return ret;
@ -676,7 +676,7 @@ namespace detail {
BoolConstant<IsSame<decltype(declval<T>().stringify()), String>>; BoolConstant<IsSame<decltype(declval<T>().stringify()), String>>;
template<typename T, typename R> template<typename T, typename R>
static True test_stringify(decltype(declval<const T &>().to_string static True test_stringify(decltype(declval<T const &>().to_string
(declval<R &>())) *); (declval<R &>())) *);
template<typename, typename> template<typename, typename>
@ -701,7 +701,7 @@ struct ToString<T, EnableIf<detail::IterableTest<T>>> {
using Argument = RemoveCv<RemoveReference<T>>; using Argument = RemoveCv<RemoveReference<T>>;
using Result = String; using Result = String;
String operator()(const T &v) const { String operator()(T const &v) const {
String ret("{"); String ret("{");
auto x = appender<String>(); auto x = appender<String>();
if (concat(x, ostd::iter(v), ", ", ToString< if (concat(x, ostd::iter(v), ", ", ToString<
@ -721,7 +721,7 @@ struct ToString<T, EnableIf<
using Argument = RemoveCv<RemoveReference<T>>; using Argument = RemoveCv<RemoveReference<T>>;
using Result = String; using Result = String;
String operator()(const T &v) const { String operator()(T const &v) const {
auto app = appender<String>(); auto app = appender<String>();
detail::TostrRange<AppenderRange<String>> sink(app); detail::TostrRange<AppenderRange<String>> sink(app);
if (!v.to_string(sink)) return String(); if (!v.to_string(sink)) return String();
@ -731,7 +731,7 @@ struct ToString<T, EnableIf<
namespace detail { namespace detail {
template<typename T> template<typename T>
void str_printf(String &s, const char *fmt, T v) { void str_printf(String &s, char const *fmt, T v) {
char buf[256]; char buf[256];
int n = snprintf(buf, sizeof(buf), fmt, v); int n = snprintf(buf, sizeof(buf), fmt, v);
s.clear(); s.clear();
@ -802,10 +802,10 @@ template<typename T> struct ToString<T *> {
} }
}; };
template<> struct ToString<const char *> { template<> struct ToString<char const *> {
using Argument = const char *; using Argument = char const *;
using Result = String; using Result = String;
String operator()(const char *s) { String operator()(char const *s) {
return String(s); return String(s);
} }
}; };
@ -821,7 +821,7 @@ template<> struct ToString<char *> {
template<> struct ToString<String> { template<> struct ToString<String> {
using Argument = String; using Argument = String;
using Result = String; using Result = String;
String operator()(const Argument &s) { String operator()(Argument const &s) {
return s; return s;
} }
}; };
@ -829,7 +829,7 @@ template<> struct ToString<String> {
template<> struct ToString<CharRange> { template<> struct ToString<CharRange> {
using Argument = CharRange; using Argument = CharRange;
using Result = String; using Result = String;
String operator()(const Argument &s) { String operator()(Argument const &s) {
return String(s); return String(s);
} }
}; };
@ -837,7 +837,7 @@ template<> struct ToString<CharRange> {
template<> struct ToString<ConstCharRange> { template<> struct ToString<ConstCharRange> {
using Argument = ConstCharRange; using Argument = ConstCharRange;
using Result = String; using Result = String;
String operator()(const Argument &s) { String operator()(Argument const &s) {
return String(s); return String(s);
} }
}; };
@ -845,7 +845,7 @@ template<> struct ToString<ConstCharRange> {
template<typename T, typename U> struct ToString<Pair<T, U>> { template<typename T, typename U> struct ToString<Pair<T, U>> {
using Argument = Pair<T, U>; using Argument = Pair<T, U>;
using Result = String; using Result = String;
String operator()(const Argument &v) { String operator()(Argument const &v) {
String ret("{"); String ret("{");
ret += ToString<RemoveCv<RemoveReference<T>>>()(v.first); ret += ToString<RemoveCv<RemoveReference<T>>>()(v.first);
ret += ", "; ret += ", ";
@ -859,7 +859,7 @@ namespace detail {
template<Size I, Size N> template<Size I, Size N>
struct TupleToString { struct TupleToString {
template<typename T> template<typename T>
static void append(String &ret, const T &tup) { static void append(String &ret, T const &tup) {
ret += ", "; ret += ", ";
ret += ToString<RemoveCv<RemoveReference< ret += ToString<RemoveCv<RemoveReference<
decltype(ostd::get<I>(tup))>>>()(ostd::get<I>(tup)); decltype(ostd::get<I>(tup))>>>()(ostd::get<I>(tup));
@ -870,13 +870,13 @@ namespace detail {
template<Size N> template<Size N>
struct TupleToString<N, N> { struct TupleToString<N, N> {
template<typename T> template<typename T>
static void append(String &, const T &) {} static void append(String &, T const &) {}
}; };
template<Size N> template<Size N>
struct TupleToString<0, N> { struct TupleToString<0, N> {
template<typename T> template<typename T>
static void append(String &ret, const T &tup) { static void append(String &ret, T const &tup) {
ret += ToString<RemoveCv<RemoveReference< ret += ToString<RemoveCv<RemoveReference<
decltype(ostd::get<0>(tup))>>>()(ostd::get<0>(tup)); decltype(ostd::get<0>(tup))>>>()(ostd::get<0>(tup));
TupleToString<1, N>::append(ret, tup); TupleToString<1, N>::append(ret, tup);
@ -887,7 +887,7 @@ namespace detail {
template<typename ...T> struct ToString<Tuple<T...>> { template<typename ...T> struct ToString<Tuple<T...>> {
using Argument = Tuple<T...>; using Argument = Tuple<T...>;
using Result = String; using Result = String;
String operator()(const Argument &v) { String operator()(Argument const &v) {
String ret("{"); String ret("{");
detail::TupleToString<0, sizeof...(T)>::append(ret, v); detail::TupleToString<0, sizeof...(T)>::append(ret, v);
ret += "}"; ret += "}";
@ -896,7 +896,7 @@ template<typename ...T> struct ToString<Tuple<T...>> {
}; };
template<typename T> template<typename T>
typename ToString<T>::Result to_string(const T &v) { typename ToString<T>::Result to_string(T const &v) {
return ToString<RemoveCv<RemoveReference<T>>>()(v); return ToString<RemoveCv<RemoveReference<T>>>()(v);
} }
@ -907,19 +907,19 @@ String to_string(std::initializer_list<T> init) {
/* TODO: rvalue ref versions for rhs when we have efficient prepend */ /* TODO: rvalue ref versions for rhs when we have efficient prepend */
inline String operator+(const String &lhs, ConstCharRange rhs) { inline String operator+(String const &lhs, ConstCharRange rhs) {
String ret(lhs); ret += rhs; return ret; String ret(lhs); ret += rhs; return ret;
} }
inline String operator+(ConstCharRange lhs, const String &rhs) { inline String operator+(ConstCharRange lhs, String const &rhs) {
String ret(lhs); ret += rhs; return ret; String ret(lhs); ret += rhs; return ret;
} }
inline String operator+(const String &lhs, char rhs) { inline String operator+(String const &lhs, char rhs) {
String ret(lhs); ret += rhs; return ret; String ret(lhs); ret += rhs; return ret;
} }
inline String operator+(char lhs, const String &rhs) { inline String operator+(char lhs, String const &rhs) {
String ret(lhs); ret += rhs; return ret; String ret(lhs); ret += rhs; return ret;
} }
@ -939,7 +939,7 @@ private:
public: public:
TempCString() = delete; TempCString() = delete;
TempCString(const TempCString &) = delete; TempCString(TempCString const &) = delete;
TempCString(TempCString &&s): p_buf(s.p_buf), p_allocated(s.p_allocated) { TempCString(TempCString &&s): p_buf(s.p_buf), p_allocated(s.p_allocated) {
s.p_buf = nullptr; s.p_buf = nullptr;
s.p_allocated = false; s.p_allocated = false;
@ -957,14 +957,14 @@ public:
if (p_allocated) delete[] p_buf; if (p_allocated) delete[] p_buf;
} }
TempCString &operator=(const TempCString &) = delete; TempCString &operator=(TempCString const &) = delete;
TempCString &operator=(TempCString &&s) { TempCString &operator=(TempCString &&s) {
swap(s); swap(s);
return *this; return *this;
} }
operator const RemoveCv<RangeValue<R>> *() const { return p_buf; } operator RemoveCv<RangeValue<R>> const *() const { return p_buf; }
const RemoveCv<RangeValue<R>> *get() const { return p_buf; } RemoveCv<RangeValue<R>> const *get() const { return p_buf; }
void swap(TempCString &s) { void swap(TempCString &s) {
detail::swap_adl(p_buf, s.p_buf); detail::swap_adl(p_buf, s.p_buf);

98
ostd/tuple.hh
View File

@ -37,17 +37,17 @@ namespace detail {
} }
template<typename A> template<typename A>
TupleLeaf(Constant<int, 0>, const A &): p_value() { TupleLeaf(Constant<int, 0>, A const &): p_value() {
static_assert(!IsReference<H>, static_assert(!IsReference<H>,
"attempt to default construct a reference element in a tuple"); "attempt to default construct a reference element in a tuple");
} }
template<typename A> template<typename A>
TupleLeaf(Constant<int, 1>, const A &a): p_value(allocator_arg, a) { TupleLeaf(Constant<int, 1>, A const &a): p_value(allocator_arg, a) {
static_assert(!IsReference<H>, static_assert(!IsReference<H>,
"attempt to default construct a reference element in a tuple"); "attempt to default construct a reference element in a tuple");
} }
template<typename A> template<typename A>
TupleLeaf(Constant<int, 2>, const A &a): p_value(a) { TupleLeaf(Constant<int, 2>, A const &a): p_value(a) {
static_assert(!IsReference<H>, static_assert(!IsReference<H>,
"attempt to default construct a reference element in a tuple"); "attempt to default construct a reference element in a tuple");
} }
@ -67,7 +67,7 @@ namespace detail {
} }
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 0>, const A &, T &&t): explicit TupleLeaf(Constant<int, 0>, A const &, T &&t):
p_value(forward<T>(t)) { p_value(forward<T>(t)) {
static_assert(!IsLvalueReference<H> || static_assert(!IsLvalueReference<H> ||
(IsLvalueReference<H> && (IsLvalueReference<H> &&
@ -78,7 +78,7 @@ namespace detail {
} }
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t): explicit TupleLeaf(Constant<int, 1>, A const &a, T &&t):
p_value(allocator_arg, a, forward<T>(t)) { p_value(allocator_arg, a, forward<T>(t)) {
static_assert(!IsLvalueReference<H> || static_assert(!IsLvalueReference<H> ||
(IsLvalueReference<H> && (IsLvalueReference<H> &&
@ -89,7 +89,7 @@ namespace detail {
} }
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t): explicit TupleLeaf(Constant<int, 2>, A const &a, T &&t):
p_value(forward<T>(t), a) { p_value(forward<T>(t), a) {
static_assert(!IsLvalueReference<H> || static_assert(!IsLvalueReference<H> ||
(IsLvalueReference<H> && (IsLvalueReference<H> &&
@ -99,7 +99,7 @@ namespace detail {
"attempt to construct a reference element in a tuple with an rvalue"); "attempt to construct a reference element in a tuple with an rvalue");
} }
TupleLeaf(const TupleLeaf &) = default; TupleLeaf(TupleLeaf const &) = default;
TupleLeaf(TupleLeaf &&) = default; TupleLeaf(TupleLeaf &&) = default;
template<typename T> template<typename T>
@ -113,10 +113,10 @@ namespace detail {
} }
H &get() { return p_value; } H &get() { return p_value; }
const H &get() const { return p_value; } H const &get() const { return p_value; }
private: private:
TupleLeaf &operator=(const TupleLeaf &); TupleLeaf &operator=(TupleLeaf const &);
H p_value; H p_value;
}; };
@ -125,32 +125,32 @@ namespace detail {
constexpr TupleLeaf() {} constexpr TupleLeaf() {}
template<typename A> template<typename A>
TupleLeaf(Constant<int, 0>, const A &) {} TupleLeaf(Constant<int, 0>, A const &) {}
template<typename A> template<typename A>
TupleLeaf(Constant<int, 1>, const A &a): TupleLeaf(Constant<int, 1>, A const &a):
H(allocator_arg, a) {} H(allocator_arg, a) {}
template<typename A> template<typename A>
TupleLeaf(Constant<int, 2>, const A &a): H(a) {} TupleLeaf(Constant<int, 2>, A const &a): H(a) {}
template<typename T, typename = EnableIf< template<typename T, typename = EnableIf<
!IsSame<Decay<T>, TupleLeaf> && IsConstructible<H, T> !IsSame<Decay<T>, TupleLeaf> && IsConstructible<H, T>
>> explicit TupleLeaf(T &&t): H(forward<T>(t)) {} >> explicit TupleLeaf(T &&t): H(forward<T>(t)) {}
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 0>, const A &, T &&t): explicit TupleLeaf(Constant<int, 0>, A const &, T &&t):
H(forward<T>(t)) {} H(forward<T>(t)) {}
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t): explicit TupleLeaf(Constant<int, 1>, A const &a, T &&t):
H(allocator_arg, a, forward<T>(t)) {} H(allocator_arg, a, forward<T>(t)) {}
template<typename T, typename A> template<typename T, typename A>
explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t): explicit TupleLeaf(Constant<int, 2>, A const &a, T &&t):
H(forward<T>(t), a) {} H(forward<T>(t), a) {}
TupleLeaf(const TupleLeaf &) = default; TupleLeaf(TupleLeaf const &) = default;
TupleLeaf(TupleLeaf &&) = default; TupleLeaf(TupleLeaf &&) = default;
template<typename T> template<typename T>
@ -164,10 +164,10 @@ namespace detail {
} }
H &get() { return (H &)*this; } H &get() { return (H &)*this; }
const H &get() const { return (const H &)*this; } H const &get() const { return (H const &)*this; }
private: private:
TupleLeaf &operator=(const TupleLeaf &); TupleLeaf &operator=(TupleLeaf const &);
}; };
} /* namespace detail */ } /* namespace detail */
@ -210,7 +210,7 @@ namespace detail {
template<typename Alloc, Size ...Ia, typename ...Aa, template<typename Alloc, Size ...Ia, typename ...Aa,
Size ...Ib, typename ...Ab, typename ...T> Size ...Ib, typename ...Ab, typename ...T>
explicit TupleBase(AllocatorArg, const Alloc &a, explicit TupleBase(AllocatorArg, Alloc const &a,
TupleIndices<Ia...>, TupleTypes<Aa...>, TupleIndices<Ia...>, TupleTypes<Aa...>,
TupleIndices<Ib...>, TupleTypes<Ab...>, TupleIndices<Ib...>, TupleTypes<Ab...>,
T &&...t): T &&...t):
@ -227,7 +227,7 @@ namespace detail {
template<typename Alloc, typename T, typename = EnableIf< template<typename Alloc, typename T, typename = EnableIf<
TupleConvertible<T, Tuple<A...>> TupleConvertible<T, Tuple<A...>>
>> TupleBase(AllocatorArg, const Alloc &a, T &&t): >> TupleBase(AllocatorArg, Alloc const &a, T &&t):
TupleLeaf<I, A>(UsesAllocatorConstructor< TupleLeaf<I, A>(UsesAllocatorConstructor<
A, Alloc, TupleElement<I, MakeTupleTypes<T>> A, Alloc, TupleElement<I, MakeTupleTypes<T>>
>, a, forward<TupleElement<I, MakeTupleTypes<T>>>(get<I>(t)))... >, a, forward<TupleElement<I, MakeTupleTypes<T>>>(get<I>(t)))...
@ -242,18 +242,18 @@ namespace detail {
return *this; return *this;
} }
TupleBase(const TupleBase &) = default; TupleBase(TupleBase const &) = default;
TupleBase(TupleBase &&) = default; TupleBase(TupleBase &&) = default;
TupleBase &operator=(const TupleBase &t) { TupleBase &operator=(TupleBase const &t) {
tuple_swallow(TupleLeaf<I, A>::operator=(((const TupleLeaf<I, tuple_swallow(TupleLeaf<I, A>::operator=(((TupleLeaf<I,A>
A> &)t).get())...); const &)t).get())...);
return *this; return *this;
} }
TupleBase &operator=(TupleBase &&t) { TupleBase &operator=(TupleBase &&t) {
tuple_swallow(TupleLeaf<I, A>::operator=(forward<A> tuple_swallow(TupleLeaf<I, A>::operator=(forward<A>
(((const TupleLeaf<I, A> &)t).get()))...); (((TupleLeaf<I, A> const &)t).get()))...);
return *this; return *this;
} }
@ -272,27 +272,27 @@ class Tuple {
friend TupleElement<I, Tuple<T...>> &get(Tuple<T...> &); friend TupleElement<I, Tuple<T...>> &get(Tuple<T...> &);
template<Size I, typename ...T> template<Size I, typename ...T>
friend const TupleElement<I, Tuple<T...>> &get(const Tuple<T...> &); friend TupleElement<I, Tuple<T...>> const &get(Tuple<T...> const &);
template<Size I, typename ...T> template<Size I, typename ...T>
friend TupleElement<I, Tuple<T...>> &&get(Tuple<T...> &&); friend TupleElement<I, Tuple<T...>> &&get(Tuple<T...> &&);
template<Size I, typename ...T> template<Size I, typename ...T>
friend const TupleElement<I, Tuple<T...>> &&get(const Tuple<T...> &&); friend TupleElement<I, Tuple<T...>> const &&get(Tuple<T...> const &&);
public: public:
template<bool D = true, typename = EnableIf< template<bool D = true, typename = EnableIf<
detail::TupleAll<(D && IsDefaultConstructible<A>)...> detail::TupleAll<(D && IsDefaultConstructible<A>)...>
>> Tuple() {} >> Tuple() {}
explicit Tuple(const A &...t): explicit Tuple(A const &...t):
p_base(detail::MakeTupleIndices<sizeof...(A)>(), p_base(detail::MakeTupleIndices<sizeof...(A)>(),
detail::MakeTupleTypes<Tuple, sizeof...(A)>(), detail::MakeTupleTypes<Tuple, sizeof...(A)>(),
detail::MakeTupleIndices<0>(), detail::MakeTupleIndices<0>(),
detail::MakeTupleTypes<Tuple, 0>(), t...) {} detail::MakeTupleTypes<Tuple, 0>(), t...) {}
template<typename Alloc> template<typename Alloc>
Tuple(AllocatorArg, const Alloc &a, const A &...t): Tuple(AllocatorArg, Alloc const &a, A const &...t):
p_base(allocator_arg, a, p_base(allocator_arg, a,
detail::MakeTupleIndices<sizeof...(A)>(), detail::MakeTupleIndices<sizeof...(A)>(),
detail::MakeTupleTypes<Tuple, sizeof...(A)>(), detail::MakeTupleTypes<Tuple, sizeof...(A)>(),
@ -367,7 +367,7 @@ public:
: sizeof...(A) : sizeof...(A)
> >
> >
>> Tuple(AllocatorArg, const Alloc &a, T &&...t): >> Tuple(AllocatorArg, Alloc const &a, T &&...t):
p_base(allocator_arg, a, detail::MakeTupleIndices<sizeof...(T)>(), p_base(allocator_arg, a, detail::MakeTupleIndices<sizeof...(T)>(),
detail::MakeTupleTypes<Tuple, sizeof...(T)>(), detail::MakeTupleTypes<Tuple, sizeof...(T)>(),
detail::MakeTupleIndices<sizeof...(A), sizeof...(T)>(), detail::MakeTupleIndices<sizeof...(A), sizeof...(T)>(),
@ -385,7 +385,7 @@ public:
template<typename Alloc, typename T, typename = EnableIf< template<typename Alloc, typename T, typename = EnableIf<
detail::TupleConvertible<T, Tuple> detail::TupleConvertible<T, Tuple>
>> Tuple(AllocatorArg, const Alloc &a, T &&t): >> Tuple(AllocatorArg, Alloc const &a, T &&t):
p_base(allocator_arg, a, forward<T>(t)) {} p_base(allocator_arg, a, forward<T>(t)) {}
template<typename T, typename = EnableIf<detail::TupleAssignable<T, Tuple>>> template<typename T, typename = EnableIf<detail::TupleAssignable<T, Tuple>>>
@ -402,8 +402,8 @@ public:
template<> class Tuple<> { template<> class Tuple<> {
public: public:
constexpr Tuple() {} constexpr Tuple() {}
template<typename A> Tuple(AllocatorArg, const A &) {} template<typename A> Tuple(AllocatorArg, A const &) {}
template<typename A> Tuple(AllocatorArg, const A &, const Tuple &) {} template<typename A> Tuple(AllocatorArg, A const &, Tuple const &) {}
void swap(Tuple &) {} void swap(Tuple &) {}
}; };
@ -416,9 +416,9 @@ inline TupleElement<I, Tuple<A...>> &get(Tuple<A...> &t) {
} }
template<Size I, typename ...A> template<Size I, typename ...A>
inline const TupleElement<I, Tuple<A...>> &get(const Tuple<A...> &t) { inline TupleElement<I, Tuple<A...>> const &get(Tuple<A...> const &t) {
using Type = TupleElement<I, Tuple<A...>>; using Type = TupleElement<I, Tuple<A...>>;
return ((const detail::TupleLeaf<I, Type> &)t.p_base).get(); return ((detail::TupleLeaf<I, Type> const &)t.p_base).get();
} }
template<Size I, typename ...A> template<Size I, typename ...A>
@ -428,9 +428,9 @@ inline TupleElement<I, Tuple<A...>> &&get(Tuple<A...> &&t) {
} }
template<Size I, typename ...A> template<Size I, typename ...A>
inline const TupleElement<I, Tuple<A...>> &&get(const Tuple<A...> &&t) { inline TupleElement<I, Tuple<A...>> const &&get(Tuple<A...> const &&t) {
using Type = TupleElement<I, Tuple<A...>>; using Type = TupleElement<I, Tuple<A...>>;
return (const Type &&)(((const detail::TupleLeaf<I, Type> &&)t.p_base).get()); return (Type const &&)(((detail::TupleLeaf<I, Type> const &&)t.p_base).get());
} }
/* tie */ /* tie */
@ -445,11 +445,11 @@ inline Tuple<T &...> tie(T &...t) {
namespace detail { namespace detail {
struct Ignore { struct Ignore {
template<typename T> template<typename T>
const Ignore &operator=(T &&) const { return *this; } Ignore const &operator=(T &&) const { return *this; }
}; };
} }
static const detail::Ignore ignore = detail::Ignore(); static detail::Ignore const ignore = detail::Ignore();
/* make tuple */ /* make tuple */
@ -489,7 +489,7 @@ namespace detail {
template<Size I> template<Size I>
struct TupleEqual { struct TupleEqual {
template<typename T, typename U> template<typename T, typename U>
bool operator()(const T &x, const U &y) { bool operator()(T const &x, U const &y) {
return TupleEqual<I - 1>()(x, y) && (get<I>(x) == get<I>(y)); return TupleEqual<I - 1>()(x, y) && (get<I>(x) == get<I>(y));
} }
}; };
@ -497,19 +497,19 @@ namespace detail {
template<> template<>
struct TupleEqual<0> { struct TupleEqual<0> {
template<typename T, typename U> template<typename T, typename U>
bool operator()(const T &, const U &) { bool operator()(T const &, U const &) {
return true; return true;
} }
}; };
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator==(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator==(Tuple<T...> const &x, Tuple<U...> const &y) {
return detail::TupleEqual<sizeof...(T)>(x, y); return detail::TupleEqual<sizeof...(T)>(x, y);
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator!=(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator!=(Tuple<T...> const &x, Tuple<U...> const &y) {
return !(x == y); return !(x == y);
} }
@ -517,7 +517,7 @@ namespace detail {
template<Size I> template<Size I>
struct TupleLess { struct TupleLess {
template<typename T, typename U> template<typename T, typename U>
bool operator()(const T &x, const U &y) { bool operator()(T const &x, U const &y) {
constexpr Size J = TupleSize<T> - I; constexpr Size J = TupleSize<T> - I;
if (get<J>(x) < get<J>(y)) return true; if (get<J>(x) < get<J>(y)) return true;
if (get<J>(y) < get<J>(x)) return false; if (get<J>(y) < get<J>(x)) return false;
@ -528,29 +528,29 @@ namespace detail {
template<> template<>
struct TupleLess<0> { struct TupleLess<0> {
template<typename T, typename U> template<typename T, typename U>
bool operator()(const T &, const U &) { bool operator()(T const &, U const &) {
return true; return true;
} }
}; };
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator<(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator<(Tuple<T...> const &x, Tuple<U...> const &y) {
return detail::TupleLess<sizeof...(T)>(x, y); return detail::TupleLess<sizeof...(T)>(x, y);
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator>(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator>(Tuple<T...> const &x, Tuple<U...> const &y) {
return y < x; return y < x;
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator<=(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator<=(Tuple<T...> const &x, Tuple<U...> const &y) {
return !(y < x); return !(y < x);
} }
template<typename ...T, typename ...U> template<typename ...T, typename ...U>
inline bool operator>=(const Tuple<T...> &x, const Tuple<U...> &y) { inline bool operator>=(Tuple<T...> const &x, Tuple<U...> const &y) {
return !(x < y); return !(x < y);
} }

62
ostd/type_traits.hh
View File

@ -261,12 +261,12 @@ template<typename T> constexpr bool IsAbstract = __is_abstract(T);
/* is const */ /* is const */
template<typename T> template<typename T>
constexpr bool IsConst = IsSame<T, const T>; constexpr bool IsConst = IsSame<T, T const>;
/* is volatile */ /* is volatile */
template<typename T> template<typename T>
constexpr bool IsVolatile = IsSame<T, volatile T>; constexpr bool IsVolatile = IsSame<T, T volatile>;
/* is empty */ /* is empty */
@ -473,7 +473,7 @@ constexpr bool IsCopyAssignable = IsAssignable<
template<typename T> template<typename T>
constexpr bool IsMoveAssignable = IsAssignable< constexpr bool IsMoveAssignable = IsAssignable<
AddLvalueReference<T>, AddLvalueReference<T>,
const AddRvalueReference<T> AddRvalueReference<T> const
>; >;
/* is destructible */ /* is destructible */
@ -532,7 +532,7 @@ namespace detail {
= __has_trivial_copy(T); = __has_trivial_copy(T);
template<typename T> template<typename T>
constexpr bool IsTriviallyConstructibleBase<T, const T &> constexpr bool IsTriviallyConstructibleBase<T, T const &>
= __has_trivial_copy(T); = __has_trivial_copy(T);
template<typename T> template<typename T>
@ -552,7 +552,7 @@ template<typename T> constexpr bool IsTriviallyDefaultConstructible
/* is trivially copy constructible */ /* is trivially copy constructible */
template<typename T> constexpr bool IsTriviallyCopyConstructible template<typename T> constexpr bool IsTriviallyCopyConstructible
= IsTriviallyConstructible<T, AddLvalueReference<const T>>; = IsTriviallyConstructible<T, AddLvalueReference<T const>>;
/* is trivially move constructible */ /* is trivially move constructible */
@ -574,7 +574,7 @@ namespace detail {
= __has_trivial_copy(T); = __has_trivial_copy(T);
template<typename T> template<typename T>
constexpr bool IsTriviallyAssignableBase<T, const T &> constexpr bool IsTriviallyAssignableBase<T, T const &>
= __has_trivial_copy(T); = __has_trivial_copy(T);
template<typename T> template<typename T>
@ -589,7 +589,7 @@ constexpr bool IsTriviallyAssignable
/* is trivially copy assignable */ /* is trivially copy assignable */
template<typename T> constexpr bool IsTriviallyCopyAssignable template<typename T> constexpr bool IsTriviallyCopyAssignable
= IsTriviallyAssignable<T, AddLvalueReference<const T>>; = IsTriviallyAssignable<T, AddLvalueReference<T const>>;
/* is trivially move assignable */ /* is trivially move assignable */
@ -673,12 +673,12 @@ namespace detail {
template<typename T> template<typename T>
struct RemoveConstBase { using Type = T; }; struct RemoveConstBase { using Type = T; };
template<typename T> template<typename T>
struct RemoveConstBase<const T> { using Type = T; }; struct RemoveConstBase<T const> { using Type = T; };
template<typename T> template<typename T>
struct RemoveVolatileBase { using Type = T; }; struct RemoveVolatileBase { using Type = T; };
template<typename T> template<typename T>
struct RemoveVolatileBase<volatile T> { using Type = T; }; struct RemoveVolatileBase<T volatile> { using Type = T; };
} }
template<typename T> template<typename T>
@ -700,7 +700,7 @@ namespace detail {
struct AddConstCore { using Type = T; }; struct AddConstCore { using Type = T; };
template<typename T> struct AddConstCore<T, false> { template<typename T> struct AddConstCore<T, false> {
using Type = const T; using Type = T const;
}; };
template<typename T> struct AddConstBase { template<typename T> struct AddConstBase {
@ -711,7 +711,7 @@ namespace detail {
struct AddVolatileCore { using Type = T; }; struct AddVolatileCore { using Type = T; };
template<typename T> struct AddVolatileCore<T, false> { template<typename T> struct AddVolatileCore<T, false> {
using Type = volatile T; using Type = T volatile;
}; };
template<typename T> struct AddVolatileBase { template<typename T> struct AddVolatileBase {
@ -780,14 +780,14 @@ namespace detail {
template<> struct AddLr<void> { template<> struct AddLr<void> {
using Type = void; using Type = void;
}; };
template<> struct AddLr<const void> { template<> struct AddLr<void const> {
using Type = const void; using Type = void const;
}; };
template<> struct AddLr<volatile void> { template<> struct AddLr<void volatile> {
using Type = volatile void; using Type = void volatile;
}; };
template<> struct AddLr<const volatile void> { template<> struct AddLr<void const volatile> {
using Type = const volatile void; using Type = void const volatile;
}; };
} }
@ -798,14 +798,14 @@ namespace detail {
template<> struct AddRr<void> { template<> struct AddRr<void> {
using Type = void; using Type = void;
}; };
template<> struct AddRr<const void> { template<> struct AddRr<void const> {
using Type = const void; using Type = void const;
}; };
template<> struct AddRr<volatile void> { template<> struct AddRr<void volatile> {
using Type = volatile void; using Type = void volatile;
}; };
template<> struct AddRr<const volatile void> { template<> struct AddRr<void const volatile> {
using Type = const volatile void; using Type = void const volatile;
}; };
} }
@ -852,8 +852,8 @@ namespace detail {
/* not a type */ /* not a type */
struct TlNat { struct TlNat {
TlNat() = delete; TlNat() = delete;
TlNat(const TlNat &) = delete; TlNat(TlNat const &) = delete;
TlNat &operator=(const TlNat &) = delete; TlNat &operator=(TlNat const &) = delete;
~TlNat() = delete; ~TlNat() = delete;
}; };
@ -891,32 +891,32 @@ namespace detail {
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T, U, true, false> { /* const */ struct ApplyCv<T, U, true, false> { /* const */
using Type = const U; using Type = U const;
}; };
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T, U, false, true> { /* volatile */ struct ApplyCv<T, U, false, true> { /* volatile */
using Type = volatile U; using Type = U volatile;
}; };
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T, U, true, true> { /* const volatile */ struct ApplyCv<T, U, true, true> { /* const volatile */
using Type = const volatile U; using Type = U const volatile;
}; };
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T &, U, true, false> { /* const */ struct ApplyCv<T &, U, true, false> { /* const */
using Type = const U &; using Type = U const &;
}; };
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T &, U, false, true> { /* volatile */ struct ApplyCv<T &, U, false, true> { /* volatile */
using Type = volatile U &; using Type = U volatile &;
}; };
template<typename T, typename U> template<typename T, typename U>
struct ApplyCv<T &, U, true, true> { /* const volatile */ struct ApplyCv<T &, U, true, true> { /* const volatile */
using Type = const volatile U &; using Type = U const volatile &;
}; };
template<typename T, bool = IsIntegral<T> || IsEnum<T>> template<typename T, bool = IsIntegral<T> || IsEnum<T>>

58
ostd/utility.hh
View File

@ -96,30 +96,30 @@ struct Pair {
Pair() = default; Pair() = default;
~Pair() = default; ~Pair() = default;
Pair(const Pair &) = default; Pair(Pair const &) = default;
Pair(Pair &&) = default; Pair(Pair &&) = default;
Pair(const T &x, const U &y): first(x), second(y) {} Pair(T const &x, U const &y): first(x), second(y) {}
template<typename TT, typename UU> template<typename TT, typename UU>
Pair(TT &&x, UU &&y): Pair(TT &&x, UU &&y):
first(forward<TT>(x)), second(forward<UU>(y)) {} first(forward<TT>(x)), second(forward<UU>(y)) {}
template<typename TT, typename UU> template<typename TT, typename UU>
Pair(const Pair<TT, UU> &v): first(v.first), second(v.second) {} Pair(Pair<TT, UU> const &v): first(v.first), second(v.second) {}
template<typename TT, typename UU> template<typename TT, typename UU>
Pair(Pair<TT, UU> &&v): Pair(Pair<TT, UU> &&v):
first(move(v.first)), second(move(v.second)) {} first(move(v.first)), second(move(v.second)) {}
Pair &operator=(const Pair &v) { Pair &operator=(Pair const &v) {
first = v.first; first = v.first;
second = v.second; second = v.second;
return *this; return *this;
} }
template<typename TT, typename UU> template<typename TT, typename UU>
Pair &operator=(const Pair<TT, UU> &v) { Pair &operator=(Pair<TT, UU> const &v) {
first = v.first; first = v.first;
second = v.second; second = v.second;
return *this; return *this;
@ -173,17 +173,17 @@ inline Pair<typename detail::MakePairRet<T>::Type,
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator==(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator==(Pair<T, U> const &x, Pair<T, U> const &y) {
return (x.first == y.first) && (x.second == y.second); return (x.first == y.first) && (x.second == y.second);
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator!=(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator!=(Pair<T, U> const &x, Pair<T, U> const &y) {
return (x.first != y.first) || (x.second != y.second); return (x.first != y.first) || (x.second != y.second);
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator<(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator<(Pair<T, U> const &x, Pair<T, U> const &y) {
return (x.first < y.first) return (x.first < y.first)
? true ? true
: ((y.first < x.first) : ((y.first < x.first)
@ -194,17 +194,17 @@ inline constexpr bool operator<(const Pair<T, U> &x, const Pair<T, U> &y) {
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator>(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator>(Pair<T, U> const &x, Pair<T, U> const &y) {
return (y < x); return (y < x);
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator<=(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator<=(Pair<T, U> const &x, Pair<T, U> const &y) {
return !(y < x); return !(y < x);
} }
template<typename T, typename U> template<typename T, typename U>
inline constexpr bool operator>=(const Pair<T, U> &x, const Pair<T, U> &y) { inline constexpr bool operator>=(Pair<T, U> const &x, Pair<T, U> const &y) {
return !(x < y); return !(x < y);
} }
@ -228,12 +228,12 @@ namespace detail {
template<typename T, typename U> template<typename T, typename U>
static T &get(Pair<T, U> &p) { return p.first; } static T &get(Pair<T, U> &p) { return p.first; }
template<typename T, typename U> template<typename T, typename U>
static const T &get(const Pair<T, U> &p) { return p.first; } static T const &get(Pair<T, U> const &p) { return p.first; }
template<typename T, typename U> template<typename T, typename U>
static T &&get(Pair<T, U> &&p) { return forward<T>(p.first); } static T &&get(Pair<T, U> &&p) { return forward<T>(p.first); }
template<typename T, typename U> template<typename T, typename U>
static const T &&get(const Pair<T, U> &&p) { static T const &&get(Pair<T, U> const &&p) {
return forward<const T>(p.first); return forward<T const>(p.first);
} }
}; };
@ -241,12 +241,12 @@ namespace detail {
template<typename T, typename U> template<typename T, typename U>
static U &get(Pair<T, U> &p) { return p.second; } static U &get(Pair<T, U> &p) { return p.second; }
template<typename T, typename U> template<typename T, typename U>
static const U &get(const Pair<T, U> &p) { return p.second; } static U const &get(Pair<T, U> const &p) { return p.second; }
template<typename T, typename U> template<typename T, typename U>
static U &&get(Pair<T, U> &&p) { return forward<U>(p.second); } static U &&get(Pair<T, U> &&p) { return forward<U>(p.second); }
template<typename T, typename U> template<typename T, typename U>
static const T &&get(const Pair<T, U> &&p) { static T const &&get(Pair<T, U> const &&p) {
return forward<const T>(p.second); return forward<T const>(p.second);
} }
}; };
} }
@ -257,7 +257,7 @@ inline TupleElement<I, Pair<T, U>> &get(Pair<T, U> &p) {
} }
template<Size I, typename T, typename U> template<Size I, typename T, typename U>
inline const TupleElement<I, Pair<T, U>> &get(const Pair<T, U> &p) { inline TupleElement<I, Pair<T, U>> const &get(Pair<T, U> const &p) {
return detail::GetPair<I>::get(p); return detail::GetPair<I>::get(p);
} }
@ -267,7 +267,7 @@ inline TupleElement<I, Pair<T, U>> &&get(Pair<T, U> &&p) {
} }
template<Size I, typename T, typename U> template<Size I, typename T, typename U>
inline const TupleElement<I, Pair<T, U>> &&get(const Pair<T, U> &&p) { inline TupleElement<I, Pair<T, U>> const &&get(Pair<T, U> const &&p) {
return detail::GetPair<I>::get(move(p)); return detail::GetPair<I>::get(move(p));
} }
@ -310,10 +310,10 @@ namespace detail {
p_second(forward<UU>(b)) {} p_second(forward<UU>(b)) {}
T &first() { return p_first; } T &first() { return p_first; }
const T &first() const { return p_first; } T const &first() const { return p_first; }
U &second() { return p_second; } U &second() { return p_second; }
const U &second() const { return p_second; } U const &second() const { return p_second; }
void swap(CompressedPairBase &v) { void swap(CompressedPairBase &v) {
swap_adl(p_first, v.p_first); swap_adl(p_first, v.p_first);
@ -330,10 +330,10 @@ namespace detail {
p_second(forward<UU>(b)) {} p_second(forward<UU>(b)) {}
T &first() { return *this; } T &first() { return *this; }
const T &first() const { return *this; } T const &first() const { return *this; }
U &second() { return p_second; } U &second() { return p_second; }
const U &second() const { return p_second; } U const &second() const { return p_second; }
void swap(CompressedPairBase &v) { void swap(CompressedPairBase &v) {
swap_adl(p_second, v.p_second); swap_adl(p_second, v.p_second);
@ -349,10 +349,10 @@ namespace detail {
p_first(forward<TT>(a)) {} p_first(forward<TT>(a)) {}
T &first() { return p_first; } T &first() { return p_first; }
const T &first() const { return p_first; } T const &first() const { return p_first; }
U &second() { return *this; } U &second() { return *this; }
const U &second() const { return *this; } U const &second() const { return *this; }
void swap(CompressedPairBase &v) { void swap(CompressedPairBase &v) {
swap_adl(p_first, v.p_first); swap_adl(p_first, v.p_first);
@ -366,10 +366,10 @@ namespace detail {
U(forward<UU>(b)) {} U(forward<UU>(b)) {}
T &first() { return *this; } T &first() { return *this; }
const T &first() const { return *this; } T const &first() const { return *this; }
U &second() { return *this; } U &second() { return *this; }
const U &second() const { return *this; } U const &second() const { return *this; }
void swap(CompressedPairBase &) {} void swap(CompressedPairBase &) {}
}; };
@ -383,10 +383,10 @@ namespace detail {
forward<UU>(b)) {} forward<UU>(b)) {}
T &first() { return Base::first(); } T &first() { return Base::first(); }
const T &first() const { return Base::first(); } T const &first() const { return Base::first(); }
U &second() { return Base::second(); } U &second() { return Base::second(); }
const U &second() const { return Base::second(); } U const &second() const { return Base::second(); }
void swap(CompressedPair &v) { void swap(CompressedPair &v) {
Base::swap(v); Base::swap(v);

102
ostd/vecmath.hh
View File

@ -18,7 +18,7 @@ struct Vec2 {
}; };
Vec2(): x(0), y(0) {} Vec2(): x(0), y(0) {}
Vec2(const Vec2 &v): x(v.x), y(v.y) {} Vec2(Vec2 const &v): x(v.x), y(v.y) {}
Vec2(T v): x(v), y(v) {} Vec2(T v): x(v), y(v) {}
Vec2(T x, T y): x(x), y(y) {} Vec2(T x, T y): x(x), y(y) {}
@ -29,7 +29,7 @@ struct Vec2 {
x += v; y += v; x += v; y += v;
return *this; return *this;
} }
Vec2 &add(const Vec2 &o) { Vec2 &add(Vec2 const &o) {
x += o.x; y += o.y; x += o.x; y += o.y;
return *this; return *this;
} }
@ -38,7 +38,7 @@ struct Vec2 {
x -= v; y -= v; x -= v; y -= v;
return *this; return *this;
} }
Vec2 &sub(const Vec2 &o) { Vec2 &sub(Vec2 const &o) {
x -= o.x; y -= o.y; x -= o.x; y -= o.y;
return *this; return *this;
} }
@ -47,7 +47,7 @@ struct Vec2 {
x *= v; y *= v; x *= v; y *= v;
return *this; return *this;
} }
Vec2 &mul(const Vec2 &o) { Vec2 &mul(Vec2 const &o) {
x *= o.x; y *= o.y; x *= o.x; y *= o.y;
return *this; return *this;
} }
@ -56,7 +56,7 @@ struct Vec2 {
x /= v; y /= v; x /= v; y /= v;
return *this; return *this;
} }
Vec2 &div(const Vec2 &o) { Vec2 &div(Vec2 const &o) {
x /= o.x; y /= o.y; x /= o.x; y /= o.y;
return *this; return *this;
} }
@ -70,63 +70,63 @@ struct Vec2 {
return (x == 0) && (y == 0); return (x == 0) && (y == 0);
} }
T dot(const Vec2<T> &o) const { T dot(Vec2<T> const &o) const {
return (x * o.x) + (y * o.y); return (x * o.x) + (y * o.y);
} }
}; };
template<typename T> template<typename T>
inline bool operator==(const Vec2<T> &a, const Vec2<T> &b) { inline bool operator==(Vec2<T> const &a, Vec2<T> const &b) {
return (a.x == b.x) && (a.y == b.y); return (a.x == b.x) && (a.y == b.y);
} }
template<typename T> template<typename T>
inline bool operator!=(const Vec2<T> &a, const Vec2<T> &b) { inline bool operator!=(Vec2<T> const &a, Vec2<T> const &b) {
return (a.x != b.x) || (a.y != b.y); return (a.x != b.x) || (a.y != b.y);
} }
template<typename T> template<typename T>
inline Vec2<T> operator+(const Vec2<T> &a, const Vec2<T> &b) { inline Vec2<T> operator+(Vec2<T> const &a, Vec2<T> const &b) {
return Vec2<T>(a).add(b); return Vec2<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator+(const Vec2<T> &a, T b) { inline Vec2<T> operator+(Vec2<T> const &a, T b) {
return Vec2<T>(a).add(b); return Vec2<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator-(const Vec2<T> &a, const Vec2<T> &b) { inline Vec2<T> operator-(Vec2<T> const &a, Vec2<T> const &b) {
return Vec2<T>(a).sub(b); return Vec2<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator-(const Vec2<T> &a, T b) { inline Vec2<T> operator-(Vec2<T> const &a, T b) {
return Vec2<T>(a).sub(b); return Vec2<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator*(const Vec2<T> &a, const Vec2<T> &b) { inline Vec2<T> operator*(Vec2<T> const &a, Vec2<T> const &b) {
return Vec2<T>(a).mul(b); return Vec2<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator*(const Vec2<T> &a, T b) { inline Vec2<T> operator*(Vec2<T> const &a, T b) {
return Vec2<T>(a).mul(b); return Vec2<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator/(const Vec2<T> &a, const Vec2<T> &b) { inline Vec2<T> operator/(Vec2<T> const &a, Vec2<T> const &b) {
return Vec2<T>(a).div(b); return Vec2<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator/(const Vec2<T> &a, T b) { inline Vec2<T> operator/(Vec2<T> const &a, T b) {
return Vec2<T>(a).div(b); return Vec2<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec2<T> operator-(const Vec2<T> &a) { inline Vec2<T> operator-(Vec2<T> const &a) {
return Vec2<T>(a).neg(); return Vec2<T>(a).neg();
} }
@ -144,7 +144,7 @@ struct Vec3 {
}; };
Vec3(): x(0), y(0), z(0) {} Vec3(): x(0), y(0), z(0) {}
Vec3(const Vec3 &v): x(v.x), y(v.y), z(v.z) {} Vec3(Vec3 const &v): x(v.x), y(v.y), z(v.z) {}
Vec3(T v): x(v), y(v), z(v) {} Vec3(T v): x(v), y(v), z(v) {}
Vec3(T x, T y, T z): x(x), y(y), z(z) {} Vec3(T x, T y, T z): x(x), y(y), z(z) {}
@ -155,7 +155,7 @@ struct Vec3 {
x += v; y += v; z += v; x += v; y += v; z += v;
return *this; return *this;
} }
Vec3 &add(const Vec3 &o) { Vec3 &add(Vec3 const &o) {
x += o.x; y += o.y; z += o.z; x += o.x; y += o.y; z += o.z;
return *this; return *this;
} }
@ -164,7 +164,7 @@ struct Vec3 {
x -= v; y -= v; z -= v; x -= v; y -= v; z -= v;
return *this; return *this;
} }
Vec3 &sub(const Vec3 &o) { Vec3 &sub(Vec3 const &o) {
x -= o.x; y -= o.y; z -= o.z; x -= o.x; y -= o.y; z -= o.z;
return *this; return *this;
} }
@ -173,7 +173,7 @@ struct Vec3 {
x *= v; y *= v; z *= v; x *= v; y *= v; z *= v;
return *this; return *this;
} }
Vec3 &mul(const Vec3 &o) { Vec3 &mul(Vec3 const &o) {
x *= o.x; y *= o.y; z *= o.z; x *= o.x; y *= o.y; z *= o.z;
return *this; return *this;
} }
@ -182,7 +182,7 @@ struct Vec3 {
x /= v; y /= v; z /= v; x /= v; y /= v; z /= v;
return *this; return *this;
} }
Vec3 &div(const Vec3 &o) { Vec3 &div(Vec3 const &o) {
x /= o.x; y /= o.y; z /= o.z; x /= o.x; y /= o.y; z /= o.z;
return *this; return *this;
} }
@ -196,63 +196,63 @@ struct Vec3 {
return (x == 0) && (y == 0) && (z == 0); return (x == 0) && (y == 0) && (z == 0);
} }
T dot(const Vec3<T> &o) const { T dot(Vec3<T> const &o) const {
return (x * o.x) + (y * o.y) + (z * o.z); return (x * o.x) + (y * o.y) + (z * o.z);
} }
}; };
template<typename T> template<typename T>
inline bool operator==(const Vec3<T> &a, const Vec3<T> &b) { inline bool operator==(Vec3<T> const &a, Vec3<T> const &b) {
return (a.x == b.x) && (a.y == b.y) && (a.z == b.z); return (a.x == b.x) && (a.y == b.y) && (a.z == b.z);
} }
template<typename T> template<typename T>
inline bool operator!=(const Vec3<T> &a, const Vec3<T> &b) { inline bool operator!=(Vec3<T> const &a, Vec3<T> const &b) {
return (a.x != b.x) || (a.y != b.y) || (a.z != b.z); return (a.x != b.x) || (a.y != b.y) || (a.z != b.z);
} }
template<typename T> template<typename T>
inline Vec3<T> operator+(const Vec3<T> &a, const Vec3<T> &b) { inline Vec3<T> operator+(Vec3<T> const &a, Vec3<T> const &b) {
return Vec3<T>(a).add(b); return Vec3<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator+(const Vec3<T> &a, T b) { inline Vec3<T> operator+(Vec3<T> const &a, T b) {
return Vec3<T>(a).add(b); return Vec3<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator-(const Vec3<T> &a, const Vec3<T> &b) { inline Vec3<T> operator-(Vec3<T> const &a, Vec3<T> const &b) {
return Vec3<T>(a).sub(b); return Vec3<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator-(const Vec3<T> &a, T b) { inline Vec3<T> operator-(Vec3<T> const &a, T b) {
return Vec3<T>(a).sub(b); return Vec3<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator*(const Vec3<T> &a, const Vec3<T> &b) { inline Vec3<T> operator*(Vec3<T> const &a, Vec3<T> const &b) {
return Vec3<T>(a).mul(b); return Vec3<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator*(const Vec3<T> &a, T b) { inline Vec3<T> operator*(Vec3<T> const &a, T b) {
return Vec3<T>(a).mul(b); return Vec3<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator/(const Vec3<T> &a, const Vec3<T> &b) { inline Vec3<T> operator/(Vec3<T> const &a, Vec3<T> const &b) {
return Vec3<T>(a).div(b); return Vec3<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator/(const Vec3<T> &a, T b) { inline Vec3<T> operator/(Vec3<T> const &a, T b) {
return Vec3<T>(a).div(b); return Vec3<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec3<T> operator-(const Vec3<T> &a) { inline Vec3<T> operator-(Vec3<T> const &a) {
return Vec3<T>(a).neg(); return Vec3<T>(a).neg();
} }
@ -270,7 +270,7 @@ struct Vec4 {
}; };
Vec4(): x(0), y(0), z(0), w(0) {} Vec4(): x(0), y(0), z(0), w(0) {}
Vec4(const Vec4 &v): x(v.x), y(v.y), z(v.z), w(v.w) {} Vec4(Vec4 const &v): x(v.x), y(v.y), z(v.z), w(v.w) {}
Vec4(T v): x(v), y(v), z(v), w(v) {} Vec4(T v): x(v), y(v), z(v), w(v) {}
Vec4(T x, T y, T z, T w): x(x), y(y), z(z), w(w) {} Vec4(T x, T y, T z, T w): x(x), y(y), z(z), w(w) {}
@ -281,7 +281,7 @@ struct Vec4 {
x += v; y += v; z += v; w += v; x += v; y += v; z += v; w += v;
return *this; return *this;
} }
Vec4 &add(const Vec4 &o) { Vec4 &add(Vec4 const &o) {
x += o.x; y += o.y; z += o.z; w += o.w; x += o.x; y += o.y; z += o.z; w += o.w;
return *this; return *this;
} }
@ -290,7 +290,7 @@ struct Vec4 {
x -= v; y -= v; z -= v; w -= v; x -= v; y -= v; z -= v; w -= v;
return *this; return *this;
} }
Vec4 &sub(const Vec4 &o) { Vec4 &sub(Vec4 const &o) {
x -= o.x; y -= o.y; z -= o.z; w -= o.w; x -= o.x; y -= o.y; z -= o.z; w -= o.w;
return *this; return *this;
} }
@ -299,7 +299,7 @@ struct Vec4 {
x *= v; y *= v; z *= v; w *= v; x *= v; y *= v; z *= v; w *= v;
return *this; return *this;
} }
Vec4 &mul(const Vec4 &o) { Vec4 &mul(Vec4 const &o) {
x *= o.x; y *= o.y; z *= o.z; w *= o.w; x *= o.x; y *= o.y; z *= o.z; w *= o.w;
return *this; return *this;
} }
@ -308,7 +308,7 @@ struct Vec4 {
x /= v; y /= v; z /= v; w /= v; x /= v; y /= v; z /= v; w /= v;
return *this; return *this;
} }
Vec4 &div(const Vec4 &o) { Vec4 &div(Vec4 const &o) {
x /= o.x; y /= o.y; z /= o.z; w /= o.w; x /= o.x; y /= o.y; z /= o.z; w /= o.w;
return *this; return *this;
} }
@ -322,63 +322,63 @@ struct Vec4 {
return (x == 0) && (y == 0) && (z == 0) && (w == 0); return (x == 0) && (y == 0) && (z == 0) && (w == 0);
} }
T dot(const Vec4<T> &o) const { T dot(Vec4<T> const &o) const {
return (x * o.x) + (y * o.y) + (z * o.z) + (w * o.w); return (x * o.x) + (y * o.y) + (z * o.z) + (w * o.w);
} }
}; };
template<typename T> template<typename T>
inline bool operator==(const Vec4<T> &a, const Vec4<T> &b) { inline bool operator==(Vec4<T> const &a, Vec4<T> const &b) {
return (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w); return (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w);
} }
template<typename T> template<typename T>
inline bool operator!=(const Vec4<T> &a, const Vec4<T> &b) { inline bool operator!=(Vec4<T> const &a, Vec4<T> const &b) {
return (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w); return (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w);
} }
template<typename T> template<typename T>
inline Vec4<T> operator+(const Vec4<T> &a, const Vec4<T> &b) { inline Vec4<T> operator+(Vec4<T> const &a, Vec4<T> const &b) {
return Vec4<T>(a).add(b); return Vec4<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator+(const Vec4<T> &a, T b) { inline Vec4<T> operator+(Vec4<T> const &a, T b) {
return Vec4<T>(a).add(b); return Vec4<T>(a).add(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator-(const Vec4<T> &a, const Vec4<T> &b) { inline Vec4<T> operator-(Vec4<T> const &a, Vec4<T> const &b) {
return Vec4<T>(a).sub(b); return Vec4<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator-(const Vec4<T> &a, T b) { inline Vec4<T> operator-(Vec4<T> const &a, T b) {
return Vec4<T>(a).sub(b); return Vec4<T>(a).sub(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator*(const Vec4<T> &a, const Vec4<T> &b) { inline Vec4<T> operator*(Vec4<T> const &a, Vec4<T> const &b) {
return Vec4<T>(a).mul(b); return Vec4<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator*(const Vec4<T> &a, T b) { inline Vec4<T> operator*(Vec4<T> const &a, T b) {
return Vec4<T>(a).mul(b); return Vec4<T>(a).mul(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator/(const Vec4<T> &a, const Vec4<T> &b) { inline Vec4<T> operator/(Vec4<T> const &a, Vec4<T> const &b) {
return Vec4<T>(a).div(b); return Vec4<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator/(const Vec4<T> &a, T b) { inline Vec4<T> operator/(Vec4<T> const &a, T b) {
return Vec4<T>(a).div(b); return Vec4<T>(a).div(b);
} }
template<typename T> template<typename T>
inline Vec4<T> operator-(const Vec4<T> &a) { inline Vec4<T> operator-(Vec4<T> const &a) {
return Vec4<T>(a).neg(); return Vec4<T>(a).neg();
} }

59
ostd/vector.hh
View File

@ -59,7 +59,7 @@ class Vector {
} }
} }
void copy_contents(const Vector &v) { void copy_contents(Vector const &v) {
if (IsPod<T>) { if (IsPod<T>) {
memcpy(p_buf.first(), v.p_buf.first(), p_len * sizeof(T)); memcpy(p_buf.first(), v.p_buf.first(), p_len * sizeof(T));
} else { } else {
@ -76,17 +76,16 @@ public:
using Difference = Ptrdiff; using Difference = Ptrdiff;
using Value = T; using Value = T;
using Reference = T &; using Reference = T &;
using ConstReference = const T &; using ConstReference = T const &;
using Pointer = AllocatorPointer<A>; using Pointer = AllocatorPointer<A>;
using ConstPointer = AllocatorConstPointer<A>; using ConstPointer = AllocatorConstPointer<A>;
using Range = PointerRange<T>; using Range = PointerRange<T>;
using ConstRange = PointerRange<const T>; using ConstRange = PointerRange<T const>;
using Allocator = A; using Allocator = A;
Vector(const A &a = A()): p_len(0), p_cap(0), p_buf(nullptr, a) {} Vector(A const &a = A()): p_len(0), p_cap(0), p_buf(nullptr, a) {}
explicit Vector(Size n, const T &val = T(), explicit Vector(Size n, T const &val = T(), A const &al = A()): Vector(al) {
const A &al = A()): Vector(al) {
if (!n) return; if (!n) return;
p_buf.first() = allocator_allocate(p_buf.second(), n); p_buf.first() = allocator_allocate(p_buf.second(), n);
p_len = p_cap = n; p_len = p_cap = n;
@ -95,14 +94,14 @@ public:
allocator_construct(p_buf.second(), cur++, val); allocator_construct(p_buf.second(), cur++, val);
} }
Vector(const Vector &v): p_len(0), p_cap(0), p_buf(nullptr, Vector(Vector const &v): p_len(0), p_cap(0), p_buf(nullptr,
allocator_container_copy(v.p_buf.second())) { allocator_container_copy(v.p_buf.second())) {
reserve(v.p_cap); reserve(v.p_cap);
p_len = v.p_len; p_len = v.p_len;
copy_contents(v); copy_contents(v);
} }
Vector(const Vector &v, const A &a): p_len(0), p_cap(0), p_buf(nullptr, a) { Vector(Vector const &v, A const &a): p_len(0), p_cap(0), p_buf(nullptr, a) {
reserve(v.p_cap); reserve(v.p_cap);
p_len = v.p_len; p_len = v.p_len;
copy_contents(v); copy_contents(v);
@ -114,7 +113,7 @@ public:
v.p_len = v.p_cap = 0; v.p_len = v.p_cap = 0;
} }
Vector(Vector &&v, const A &a): p_len(0), p_cap(0), p_buf(nullptr, a) { Vector(Vector &&v, A const &a): p_len(0), p_cap(0), p_buf(nullptr, a) {
if (a != v.p_buf.second()) { if (a != v.p_buf.second()) {
reserve(v.p_cap); reserve(v.p_cap);
p_len = v.p_len; p_len = v.p_len;
@ -136,7 +135,7 @@ public:
v.p_len = v.p_cap = 0; v.p_len = v.p_cap = 0;
} }
Vector(ConstRange r, const A &a = A()): Vector(a) { Vector(ConstRange r, A const &a = A()): Vector(a) {
reserve(r.size()); reserve(r.size());
if (IsPod<T>) { if (IsPod<T>) {
memcpy(p_buf.first(), &r[0], r.size() * sizeof(T)); memcpy(p_buf.first(), &r[0], r.size() * sizeof(T));
@ -147,12 +146,12 @@ public:
p_len = r.size(); p_len = r.size();
} }
Vector(InitializerList<T> v, const A &a = A()): Vector(InitializerList<T> v, A const &a = A()):
Vector(ConstRange(v.begin(), v.size()), a) {} Vector(ConstRange(v.begin(), v.size()), a) {}
template<typename R, typename = EnableIf< template<typename R, typename = EnableIf<
IsInputRange<R> && IsConvertible<RangeReference<R>, Value> IsInputRange<R> && IsConvertible<RangeReference<R>, Value>
>> Vector(R range, const A &a = A()): Vector(a) { >> Vector(R range, A const &a = A()): Vector(a) {
ctor_from_range(range); ctor_from_range(range);
} }
@ -170,7 +169,7 @@ public:
p_len = 0; p_len = 0;
} }
Vector &operator=(const Vector &v) { Vector &operator=(Vector const &v) {
if (this == &v) return *this; if (this == &v) return *this;
clear(); clear();
if (AllocatorPropagateOnContainerCopyAssignment<A>) { if (AllocatorPropagateOnContainerCopyAssignment<A>) {
@ -225,7 +224,7 @@ public:
return *this; return *this;
} }
void resize(Size n, const T &v = T()) { void resize(Size n, T const &v = T()) {
if (!n) { if (!n) {
clear(); clear();
return; return;
@ -272,18 +271,18 @@ public:
} }
T &operator[](Size i) { return p_buf.first()[i]; } T &operator[](Size i) { return p_buf.first()[i]; }
const T &operator[](Size i) const { return p_buf.first()[i]; } T const &operator[](Size i) const { return p_buf.first()[i]; }
T *at(Size i) { T *at(Size i) {
if (!in_range(i)) return nullptr; if (!in_range(i)) return nullptr;
return &p_buf.first()[i]; return &p_buf.first()[i];
} }
const T *at(Size i) const { T const *at(Size i) const {
if (!in_range(i)) return nullptr; if (!in_range(i)) return nullptr;
return &p_buf.first()[i]; return &p_buf.first()[i];
} }
T &push(const T &v) { T &push(T const &v) {
if (p_len == p_cap) reserve(p_len + 1); if (p_len == p_cap) reserve(p_len + 1);
allocator_construct(p_buf.second(), &p_buf.first()[p_len], v); allocator_construct(p_buf.second(), &p_buf.first()[p_len], v);
return p_buf.first()[p_len++]; return p_buf.first()[p_len++];
@ -301,7 +300,7 @@ public:
return p_buf.first()[p_len++]; return p_buf.first()[p_len++];
} }
Range push_n(const T *v, Size n) { Range push_n(T const *v, Size n) {
reserve(p_len + n); reserve(p_len + n);
if (IsPod<T>) { if (IsPod<T>) {
memcpy(p_buf.first() + p_len, v, n * sizeof(T)); memcpy(p_buf.first() + p_len, v, n * sizeof(T));
@ -331,13 +330,13 @@ public:
} }
T &front() { return p_buf.first()[0]; } T &front() { return p_buf.first()[0]; }
const T &front() const { return p_buf.first()[0]; } T const &front() const { return p_buf.first()[0]; }
T &back() { return p_buf.first()[p_len - 1]; } T &back() { return p_buf.first()[p_len - 1]; }
const T &back() const { return p_buf.first()[p_len - 1]; } T const &back() const { return p_buf.first()[p_len - 1]; }
Value *data() { return (Value *)p_buf.first(); } Value *data() { return (Value *)p_buf.first(); }
const Value *data() const { return (const Value *)p_buf.first(); } Value const *data() const { return (Value const *)p_buf.first(); }
Size size() const { return p_len; } Size size() const { return p_len; }
Size capacity() const { return p_cap; } Size capacity() const { return p_cap; }
@ -350,7 +349,7 @@ public:
bool in_range(Size idx) { return idx < p_len; } bool in_range(Size idx) { return idx < p_len; }
bool in_range(int idx) { return idx >= 0 && Size(idx) < p_len; } bool in_range(int idx) { return idx >= 0 && Size(idx) < p_len; }
bool in_range(const Value *ptr) { bool in_range(Value const *ptr) {
return ptr >= p_buf.first() && ptr < &p_buf.first()[p_len]; return ptr >= p_buf.first() && ptr < &p_buf.first()[p_len];
} }
@ -367,13 +366,13 @@ public:
return Range(&p_buf.first()[idx], &p_buf.first()[p_len]); return Range(&p_buf.first()[idx], &p_buf.first()[p_len]);
} }
Range insert(Size idx, const T &v) { Range insert(Size idx, T const &v) {
insert_base(idx, 1); insert_base(idx, 1);
p_buf.first()[idx] = v; p_buf.first()[idx] = v;
return Range(&p_buf.first()[idx], &p_buf.first()[p_len]); return Range(&p_buf.first()[idx], &p_buf.first()[p_len]);
} }
Range insert(Size idx, Size n, const T &v) { Range insert(Size idx, Size n, T const &v) {
insert_base(idx, n); insert_base(idx, n);
for (Size i = 0; i < n; ++i) { for (Size i = 0; i < n; ++i) {
p_buf.first()[idx + i] = v; p_buf.first()[idx + i] = v;
@ -424,17 +423,17 @@ public:
}; };
template<typename T, typename A> template<typename T, typename A>
inline bool operator==(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator==(Vector<T, A> const &x, Vector<T, A> const &y) {
return equal(x.iter(), y.iter()); return equal(x.iter(), y.iter());
} }
template<typename T, typename A> template<typename T, typename A>
inline bool operator!=(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator!=(Vector<T, A> const &x, Vector<T, A> const &y) {
return !(x == y); return !(x == y);
} }
template<typename T, typename A> template<typename T, typename A>
inline bool operator<(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator<(Vector<T, A> const &x, Vector<T, A> const &y) {
using Range = typename Vector<T, A>::Range; using Range = typename Vector<T, A>::Range;
Range range1 = x.iter(), range2 = y.iter(); Range range1 = x.iter(), range2 = y.iter();
while (!range1.empty() && !range2.empty()) { while (!range1.empty() && !range2.empty()) {
@ -447,17 +446,17 @@ inline bool operator<(const Vector<T, A> &x, const Vector<T, A> &y) {
} }
template<typename T, typename A> template<typename T, typename A>
inline bool operator>(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator>(Vector<T, A> const &x, Vector<T, A> const &y) {
return (y < x); return (y < x);
} }
template<typename T, typename A> template<typename T, typename A>
inline bool operator<=(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator<=(Vector<T, A> const &x, Vector<T, A> const &y) {
return !(y < x); return !(y < x);
} }
template<typename T, typename A> template<typename T, typename A>
inline bool operator>=(const Vector<T, A> &x, const Vector<T, A> &y) { inline bool operator>=(Vector<T, A> const &x, Vector<T, A> const &y) {
return !(x < y); return !(x < y);
} }