From bfc94e31d7b42511f051bfd6d506e35725ed8035 Mon Sep 17 00:00:00 2001 From: q66 Date: Tue, 2 Jun 2015 00:57:34 +0100 Subject: [PATCH] uglify the code by using unique identifiers only (prevent macro conflicts) --- octa/algorithm.h | 706 ++++++++++---------- octa/array.h | 62 +- octa/atomic.h | 1402 +++++++++++++++------------------------ octa/functional.h | 671 ++++++++++--------- octa/initializer_list.h | 26 +- octa/memory.h | 642 +++++++++--------- octa/range.h | 1012 ++++++++++++++-------------- octa/string.h | 387 +++++------ octa/type_traits.h | 948 +++++++++++++------------- octa/utility.h | 112 ++-- octa/vector.h | 365 +++++----- 11 files changed, 3024 insertions(+), 3309 deletions(-) diff --git a/octa/algorithm.h b/octa/algorithm.h index 2d89e2f..63a23ac 100644 --- a/octa/algorithm.h +++ b/octa/algorithm.h @@ -17,545 +17,557 @@ namespace octa { /* partitioning */ - template - R partition(R range, U pred) { - R ret = range; - for (; !range.empty(); range.pop_front()) { - if (pred(range.front())) { - swap(range.front(), ret.front()); - ret.pop_front(); + template + _R partition(_R __range, _U __pred) { + _R __ret = __range; + for (; !__range.empty(); __range.pop_front()) { + if (__pred(__range.front())) { + octa::swap(__range.front(), __ret.front()); + __ret.pop_front(); } } - return ret; + return __ret; } - template - bool is_partitioned(R range, P pred) { - for (; !range.empty() && pred(range.front()); range.pop_front()); - for (; !range.empty(); range.pop_front()) - if (pred(range.front())) return false; + template + bool is_partitioned(_R __range, _P __pred) { + for (; !__range.empty() && __pred(__range.front()); __range.pop_front()); + for (; !__range.empty(); __range.pop_front()) + if (__pred(__range.front())) return false; return true; } /* sorting */ - template - void __octa_insort(R range, C compare) { - RangeSize rlen = range.size(); - for (RangeSize i = 1; i < rlen; ++i) { - RangeSize j = i; - RangeReference v = range[i]; - while (j > 0 && !compare(range[j - 1], v)) { - range[j] = range[j - 1]; - --j; + template + void __octa_insort(_R __range, _C __compare) { + octa::RangeSize<_R> __rlen = __range.size(); + for (octa::RangeSize<_R> __i = 1; __i < __rlen; ++__i) { + octa::RangeSize<_R> __j = __i; + octa::RangeReference<_R> __v = __range[__i]; + while (__j > 0 && !__compare(__range[__j - 1], __v)) { + __range[__j] = __range[__j - 1]; + --__j; } - range[j] = v; + __range[__j] = __v; } } - template + template struct __OctaUnaryCompare { - const T &val; - U comp; - bool operator()(const T &v) const { return comp(v, val); } + const _T &__val; + _U __comp; + bool operator()(const _T &__v) const { return __comp(__v, __val); } }; - template - void __octa_hs_sift_down(R range, RangeSize s, - RangeSize e, C compare) { - RangeSize r = s; - while ((r * 2 + 1) <= e) { - RangeSize ch = r * 2 + 1; - RangeSize sw = r; - if (compare(range[sw], range[ch])) - sw = ch; - if (((ch + 1) <= e) && compare(range[sw], range[ch + 1])) - sw = ch + 1; - if (sw != r) { - swap(range[r], range[sw]); - r = sw; + template + void __octa_hs_sift_down(_R __range, octa::RangeSize<_R> __s, + octa::RangeSize<_R> __e, _C __compare) { + octa::RangeSize<_R> __r = __s; + while ((__r * 2 + 1) <= __e) { + octa::RangeSize<_R> __ch = __r * 2 + 1; + octa::RangeSize<_R> __sw = __r; + if (__compare(__range[__sw], __range[__ch])) + __sw = __ch; + if (((__ch + 1) <= __e) && __compare(__range[__sw], __range[__ch + 1])) + __sw = __ch + 1; + if (__sw != __r) { + octa::swap(__range[__r], __range[__sw]); + __r = __sw; } else return; } } - template - void __octa_heapsort(R range, C compare) { - RangeSize len = range.size(); - RangeSize st = (len - 2) / 2; + template + void __octa_heapsort(_R __range, _C __compare) { + octa::RangeSize<_R> __len = __range.size(); + octa::RangeSize<_R> __st = (__len - 2) / 2; for (;;) { - __octa_hs_sift_down(range, st, len - 1, compare); - if (st-- == 0) break; + __octa_hs_sift_down(__range, __st, __len - 1, __compare); + if (__st-- == 0) break; } - RangeSize e = len - 1; - while (e > 0) { - swap(range[e], range[0]); - --e; - __octa_hs_sift_down(range, 0, e, compare); + octa::RangeSize<_R> __e = __len - 1; + while (__e > 0) { + octa::swap(__range[__e], __range[0]); + --__e; + __octa_hs_sift_down(__range, 0, __e, __compare); } } - template - void __octa_introloop(R range, C compare, RangeSize depth) { - if (range.size() <= 10) { - __octa_insort(range, compare); + template + void __octa_introloop(_R __range, _C __compare, RangeSize<_R> __depth) { + if (__range.size() <= 10) { + __octa_insort(__range, __compare); return; } - if (depth == 0) { - __octa_heapsort(range, compare); + if (__depth == 0) { + __octa_heapsort(__range, __compare); return; } - RangeReference p = range[range.size() / 2]; - swap(p, range.back()); - R r = partition(range, __OctaUnaryCompare{ p, compare }); - R l = range.slice(0, range.size() - r.size()); - swap(r.front(), r.back()); - __octa_introloop(l, compare, depth - 1); - __octa_introloop(r, compare, depth - 1); + octa::RangeReference<_R> __p = __range[__range.size() / 2]; + octa::swap(__p, __range.back()); + _R __r = octa::partition(__range, + __OctaUnaryCompare{ __p, __compare }); + _R __l = __range.slice(0, __range.size() - __r.size()); + octa::swap(__r.front(), __r.back()); + __octa_introloop(__l, __compare, __depth - 1); + __octa_introloop(__r, __compare, __depth - 1); } - template - void __octa_introsort(R range, C compare) { - __octa_introloop(range, compare, RangeSize(2 - * (log(range.size()) / log(2)))); + template + void __octa_introsort(_R __range, _C __compare) { + __octa_introloop(__range, __compare, octa::RangeSize<_R>(2 + * (log(__range.size()) / log(2)))); } - template - void sort(R range, C compare) { - __octa_introsort(range, compare); + template + void sort(_R __range, _C __compare) { + __octa_introsort(__range, __compare); } - template - void sort(R range) { - sort(range, Less>()); + template + void sort(_R __range) { + sort(__range, octa::Less>()); } /* min/max(_element) */ - template - inline const T &min(const T &a, const T &b) { - return (a < b) ? a : b; + template + inline const _T &min(const _T &__a, const _T &__b) { + return (__a < __b) ? __a : __b; } - template - inline const T &min(const T &a, const T &b, C compare) { - return compare(a, b) ? a : b; + template + inline const _T &min(const _T &__a, const _T &__b, _C __compare) { + return __compare(__a, __b) ? __a : __b; } - template - inline const T &max(const T &a, const T &b) { - return (a < b) ? b : a; + template + inline const _T &max(const _T &__a, const _T &__b) { + return (__a < __b) ? __b : __a; } - template - inline const T &max(const T &a, const T &b, C compare) { - return compare(a, b) ? b : a; + template + inline const _T &max(const _T &__a, const _T &__b, _C __compare) { + return __compare(__a, __b) ? __b : __a; } - template - inline R min_element(R range) { - R r = range; - for (; !range.empty(); range.pop_front()) - if (min(r.front(), range.front()) == range.front()) - r = range; - return r; + template + inline _R min_element(_R __range) { + _R __r = __range; + for (; !__range.empty(); __range.pop_front()) + if (octa::min(__r.front(), __range.front()) == __range.front()) + __r = __range; + return __r; } - template - inline R min_element(R range, C compare) { - R r = range; - for (; !range.empty(); range.pop_front()) - if (min(r.front(), range.front(), compare) == range.front()) - r = range; - return r; + template + inline _R min_element(_R __range, _C __compare) { + _R __r = __range; + for (; !__range.empty(); __range.pop_front()) + if (octa::min(__r.front(), __range.front(), __compare) == __range.front()) + __r = __range; + return __r; } - template - inline R max_element(R range) { - R r = range; - for (; !range.empty(); range.pop_front()) - if (max(r.front(), range.front()) == range.front()) - r = range; - return r; + template + inline _R max_element(_R __range) { + _R __r = __range; + for (; !__range.empty(); __range.pop_front()) + if (octa::max(__r.front(), __range.front()) == __range.front()) + __r = __range; + return __r; } - template - inline R max_element(R range, C compare) { - R r = range; - for (; !range.empty(); range.pop_front()) - if (max(r.front(), range.front(), compare) == range.front()) - r = range; - return r; + template + inline _R max_element(_R __range, _C __compare) { + _R __r = __range; + for (; !__range.empty(); __range.pop_front()) + if (octa::max(__r.front(), __range.front(), __compare) == __range.front()) + __r = __range; + return __r; } - using std::initializer_list; - - template - inline T min(initializer_list il) { - return min_element(each(il)).front(); + template + inline _T min(std::initializer_list<_T> __il) { + return octa::min_element(octa::each(__il)).front(); } - template - inline T min(initializer_list il, C compare) { - return min_element(each(il), compare).front(); + template + inline _T min(std::initializer_list<_T> __il, _C __compare) { + return octa::min_element(octa::each(__il), __compare).front(); } - template - inline T max(initializer_list il) { - return max_element(each(il)).front(); + template + inline _T max(std::initializer_list<_T> __il) { + return octa::max_element(octa::each(__il)).front(); } - template - inline T max(initializer_list il, C compare) { - return max_element(each(il), compare).front(); + template + inline _T max(std::initializer_list<_T> __il, _C __compare) { + return octa::max_element(octa::each(__il), __compare).front(); } /* clamp */ - template - inline T clamp(const T &v, const U &lo, const U &hi) { - return max(T(lo), min(v, T(hi))); + template + inline _T clamp(const _T &__v, const _U &__lo, const _U &__hi) { + return octa::max(_T(__lo), octa::min(__v, _T(__hi))); } - template - inline T clamp(const T &v, const U &lo, const U &hi, C compare) { - return max(T(lo), min(v, T(hi), compare), compare); + template + inline _T clamp(const _T &__v, const _U &__lo, const _U &__hi, _C __compare) { + return octa::max(_T(__lo), octa::min(__v, _T(__hi), __compare), __compare); } /* algos that don't change the range */ - template - F for_each(R range, F func) { - for (; !range.empty(); range.pop_front()) - func(range.front()); - return move(func); + template + _F for_each(_R __range, _F __func) { + for (; !__range.empty(); __range.pop_front()) + __func(__range.front()); + return octa::move(__func); } - template - bool all_of(R range, P pred) { - for (; !range.empty(); range.pop_front()) - if (!pred(range.front())) return false; + template + bool all_of(_R __range, _P __pred) { + for (; !__range.empty(); __range.pop_front()) + if (!__pred(__range.front())) return false; return true; } - template - bool any_of(R range, P pred) { - for (; !range.empty(); range.pop_front()) - if (pred(range.front())) return true; + template + bool any_of(_R __range, _P __pred) { + for (; !__range.empty(); __range.pop_front()) + if (__pred(__range.front())) return true; return false; } - template - bool none_of(R range, P pred) { - for (; !range.empty(); range.pop_front()) - if (pred(range.front())) return false; + template + bool none_of(_R __range, _P __pred) { + for (; !__range.empty(); __range.pop_front()) + if (__pred(__range.front())) return false; return true; } - template - R find(R range, const T &v) { - for (; !range.empty(); range.pop_front()) - if (range.front() == v) + template + _R find(_R __range, const _T &__v) { + for (; !__range.empty(); __range.pop_front()) + if (__range.front() == __v) break; - return range; + return __range; } - template - R find_if(R range, P pred) { - for (; !range.empty(); range.pop_front()) - if (pred(range.front())) + template + _R find_if(_R __range, _P __pred) { + for (; !__range.empty(); __range.pop_front()) + if (__pred(__range.front())) break; - return range; + return __range; } - template - R find_if_not(R range, P pred) { - for (; !range.empty(); range.pop_front()) - if (!pred(range.front())) + template + _R find_if_not(_R __range, _P __pred) { + for (; !__range.empty(); __range.pop_front()) + if (!__pred(__range.front())) break; - return range; + return __range; } - template - RangeSize count(R range, const T &v) { - RangeSize ret = 0; - for (; !range.empty(); range.pop_front()) - if (range.front() == v) - ++ret; - return ret; + template + RangeSize<_R> count(_R __range, const _T &__v) { + RangeSize<_R> __ret = 0; + for (; !__range.empty(); __range.pop_front()) + if (__range.front() == __v) + ++__ret; + return __ret; } - template - RangeSize count_if(R range, P pred) { - RangeSize ret = 0; - for (; !range.empty(); range.pop_front()) - if (pred(range.front())) - ++ret; - return ret; + template + RangeSize<_R> count_if(_R __range, _P __pred) { + RangeSize<_R> __ret = 0; + for (; !__range.empty(); __range.pop_front()) + if (__pred(__range.front())) + ++__ret; + return __ret; } - template - RangeSize count_if_not(R range, P pred) { - RangeSize ret = 0; - for (; !range.empty(); range.pop_front()) - if (!pred(range.front())) - ++ret; - return ret; + template + RangeSize<_R> count_if_not(_R __range, _P __pred) { + RangeSize<_R> __ret = 0; + for (; !__range.empty(); __range.pop_front()) + if (!__pred(__range.front())) + ++__ret; + return __ret; } - template - bool equal(R range1, R range2) { - for (; !range1.empty(); range1.pop_front()) { - if (range2.empty() || (range1.front() != range2.front())) + template + bool equal(_R __range1, _R __range2) { + for (; !__range1.empty(); __range1.pop_front()) { + if (__range2.empty() || (__range1.front() != __range2.front())) return false; - range2.pop_front(); + __range2.pop_front(); } - return range2.empty(); + return __range2.empty(); } /* algos that modify ranges or work with output ranges */ - template - R2 copy(R1 irange, R2 orange) { - for (; !irange.empty(); irange.pop_front()) - orange.put(irange.front()); - return orange; + template + _R2 copy(_R1 __irange, _R2 __orange) { + for (; !__irange.empty(); __irange.pop_front()) + __orange.put(__irange.front()); + return __orange; } - template - R2 copy_if(R1 irange, R2 orange, P pred) { - for (; !irange.empty(); irange.pop_front()) - if (pred(irange.front())) - orange.put(irange.front()); - return orange; + template + _R2 copy_if(_R1 __irange, _R2 __orange, _P __pred) { + for (; !__irange.empty(); __irange.pop_front()) + if (__pred(__irange.front())) + __orange.put(__irange.front()); + return __orange; } - template - R2 copy_if_not(R1 irange, R2 orange, P pred) { - for (; !irange.empty(); irange.pop_front()) - if (!pred(irange.front())) - orange.put(irange.front()); - return orange; + template + _R2 copy_if_not(_R1 __irange, _R2 __orange, _P __pred) { + for (; !__irange.empty(); __irange.pop_front()) + if (!__pred(__irange.front())) + __orange.put(__irange.front()); + return __orange; } - template - R2 move(R1 irange, R2 orange) { - for (; !irange.empty(); irange.pop_front()) - orange.put(move(irange.front())); - return orange; + template + _R2 move(_R1 __irange, _R2 __orange) { + for (; !__irange.empty(); __irange.pop_front()) + __orange.put(octa::move(__irange.front())); + return __orange; } - template - void reverse(R range) { - while (!range.empty()) { - swap(range.front(), range.back()); - range.pop_front(); - range.pop_back(); + template + void reverse(_R __range) { + while (!__range.empty()) { + octa::swap(__range.front(), __range.back()); + __range.pop_front(); + __range.pop_back(); } } - template - R2 reverse_copy(R1 irange, R2 orange) { - for (; !irange.empty(); irange.pop_back()) - orange.put(irange.back()); - return orange; + template + _R2 reverse_copy(_R1 __irange, _R2 __orange) { + for (; !__irange.empty(); __irange.pop_back()) + __orange.put(__irange.back()); + return __orange; } - template - void fill(R range, const T &v) { - for (; !range.empty(); range.pop_front()) - range.front() = v; + template + void fill(_R __range, const _T &__v) { + for (; !__range.empty(); __range.pop_front()) + __range.front() = __v; } - template - void generate(R range, F gen) { - for (; !range.empty(); range.pop_front()) - range.front() = gen(); + template + void generate(_R __range, _F __gen) { + for (; !__range.empty(); __range.pop_front()) + __range.front() = __gen(); } - template - Pair swap_ranges(R1 range1, R2 range2) { - while (!range1.empty() && !range2.empty()) { - swap(range1.front(), range2.front()); - range1.pop_front(); - range2.pop_front(); + template + octa::Pair<_R1, _R2> swap_ranges(_R1 __range1, _R2 __range2) { + while (!__range1.empty() && !__range2.empty()) { + octa::swap(__range1.front(), __range2.front()); + __range1.pop_front(); + __range2.pop_front(); } - return Pair(range1, range2); + return octa::Pair<_R1, _R2>(__range1, __range2); } - template - void iota(R range, T value) { - for (; !range.empty(); range.pop_front()) - range.front() = value++; + template + void iota(_R __range, _T __value) { + for (; !__range.empty(); __range.pop_front()) + __range.front() = __value++; } - template - T foldl(R range, T init) { - for (; !range.empty(); range.pop_front()) - init = init + range.front(); - return init; + template + _T foldl(_R __range, _T __init) { + for (; !__range.empty(); __range.pop_front()) + __init = __init + __range.front(); + return __init; } - template - T foldl(R range, T init, F func) { - for (; !range.empty(); range.pop_front()) - init = func(init, range.front()); - return init; + template + _T foldl(_R __range, _T __init, _F __func) { + for (; !__range.empty(); __range.pop_front()) + __init = __func(__init, __range.front()); + return __init; } - template - T foldr(R range, T init) { - for (; !range.empty(); range.pop_back()) - init = init + range.back(); - return init; + template + _T foldr(_R __range, _T __init) { + for (; !__range.empty(); __range.pop_back()) + __init = __init + __range.back(); + return __init; } - template - T foldr(R range, T init, F func) { - for (; !range.empty(); range.pop_back()) - init = func(init, range.back()); - return init; + template + _T foldr(_R __range, _T __init, _F __func) { + for (; !__range.empty(); __range.pop_back()) + __init = __func(__init, __range.back()); + return __init; } - template + template struct MapRange: InputRange< - MapRange, RangeCategory, R, R, RangeSize + MapRange<_T, _R>, octa::RangeCategory<_T>, _R, _R, octa::RangeSize<_T> > { private: - T p_range; - Function)> p_func; + _T __range; + octa::Function<_R(octa::RangeReference<_T>)> __func; public: - MapRange(): p_range(), p_func() {} - template - MapRange(const T &range, const F &func): p_range(range), p_func(func) {} - MapRange(const MapRange &it): p_range(it.p_range), p_func(it.p_func) {} - MapRange(MapRange &&it): p_range(move(it.p_range)), p_func(move(it.p_func)) {} + MapRange(): __range(), __func() {} + template + MapRange(const _T &__range, const _F &__func): + __range(__range), __func(__func) {} + MapRange(const MapRange &__it): + __range(__it.__range), __func(__it.__func) {} + MapRange(MapRange &&__it): + __range(move(__it.__range)), __func(move(__it.__func)) {} - MapRange &operator=(const MapRange &v) { - p_range = v.p_range; - p_func = v.p_func; + MapRange &operator=(const MapRange &__v) { + __range = __v.__range; + __func = __v.__func; return *this; } - MapRange &operator=(MapRange &&v) { - p_range = move(v.p_range); - p_func = move(v.p_func); + MapRange &operator=(MapRange &&__v) { + __range = move(__v.__range); + __func = move(__v.__func); return *this; } - bool empty() const { return p_range.empty(); } - RangeSize size() const { return p_range.size(); } + bool empty() const { return __range.empty(); } + octa::RangeSize<_T> size() const { return __range.size(); } - bool equals_front(const MapRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const MapRange &__r) const { + return __range.equals_front(__r.__range); } - bool equals_back(const MapRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_back(const MapRange &__r) const { + return __range.equals_front(__r.__range); } - RangeDifference distance_front(const MapRange &range) const { - return p_range.distance_front(range.p_range); + octa::RangeDifference<_T> distance_front(const MapRange &__r) const { + return __range.distance_front(__r.__range); } - RangeDifference distance_back(const MapRange &range) const { - return p_range.distance_back(range.p_range); + octa::RangeDifference<_T> distance_back(const MapRange &__r) const { + return __range.distance_back(__r.__range); } - bool pop_front() { return p_range.pop_front(); } - bool pop_back() { return p_range.pop_back(); } + bool pop_front() { return __range.pop_front(); } + bool pop_back() { return __range.pop_back(); } - bool push_front() { return p_range.pop_front(); } - bool push_back() { return p_range.push_back(); } + bool push_front() { return __range.pop_front(); } + bool push_back() { return __range.push_back(); } - RangeSize pop_front_n(RangeSize n) { p_range.pop_front_n(n); } - RangeSize pop_back_n(RangeSize n) { p_range.pop_back_n(n); } - - RangeSize push_front_n(RangeSize n) { return p_range.push_front_n(n); } - RangeSize push_back_n(RangeSize n) { return p_range.push_back_n(n); } - - R front() const { return p_func(p_range.front()); } - R back() const { return p_func(p_range.back()); } - - R operator[](RangeSize idx) const { - return p_func(p_range[idx]); + octa::RangeSize<_T> pop_front_n(octa::RangeSize<_T> __n) { + __range.pop_front_n(__n); + } + octa::RangeSize<_T> pop_back_n(octa::RangeSize<_T> __n) { + __range.pop_back_n(__n); } - MapRange slice(RangeSize start, RangeSize end) { - return MapRange(p_range.slice(start, end), p_func); + octa::RangeSize<_T> push_front_n(octa::RangeSize<_T> __n) { + return __range.push_front_n(__n); + } + octa::RangeSize<_T> push_back_n(octa::RangeSize<_T> __n) { + return __range.push_back_n(__n); + } + + _R front() const { return __func(__range.front()); } + _R back() const { return __func(__range.back()); } + + _R operator[](octa::RangeSize<_T> __idx) const { + return __func(__range[__idx]); + } + + MapRange<_T, _R> slice(octa::RangeSize<_T> __start, + octa::RangeSize<_T> __end) { + return MapRange<_T, _R>(__range.slice(__start, __end), __func); } }; - template - using __OctaMapReturnType = decltype(declval()(declval>())); + template using __OctaMapReturnType + = decltype(declval<_F>()(octa::declval>())); - template - MapRange> map(R range, F func) { - return MapRange>(range, func); + template + MapRange<_R, __OctaMapReturnType<_R, _F>> map(_R __range, _F __func) { + return octa::MapRange<_R, __OctaMapReturnType<_R, _F>>(__range, __func); } - template + template struct FilterRange: InputRange< - FilterRange, CommonType, ForwardRangeTag>, - RangeValue, RangeReference, RangeSize + FilterRange<_T>, octa::CommonType, + octa::ForwardRangeTag>, + octa::RangeValue<_T>, octa::RangeReference<_T>, octa::RangeSize<_T> > { private: - T p_range; - Function)> p_pred; + _T __range; + octa::Function)> __pred; void advance_valid() { - while (!p_range.empty() && !p_pred(front())) p_range.pop_front(); + while (!__range.empty() && !__pred(front())) __range.pop_front(); } public: - FilterRange(): p_range(), p_pred() {} + FilterRange(): __range(), __pred() {} - template - FilterRange(const T &range, const P &pred): p_range(range), - p_pred(pred) { + template + FilterRange(const _T &__range, const _P &__pred): __range(__range), + __pred(__pred) { advance_valid(); } - FilterRange(const FilterRange &it): p_range(it.p_range), - p_pred(it.p_pred) { + FilterRange(const FilterRange &__it): __range(__it.__range), + __pred(__it.__pred) { advance_valid(); } - FilterRange(FilterRange &&it): p_range(move(it.p_range)), - p_pred(move(it.p_pred)) { + FilterRange(FilterRange &&__it): __range(move(__it.__range)), + __pred(move(__it.__pred)) { advance_valid(); } - FilterRange &operator=(const FilterRange &v) { - p_range = v.p_range; - p_pred = v.p_pred; + FilterRange &operator=(const FilterRange &__v) { + __range = __v.__range; + __pred = __v.__pred; advance_valid(); return *this; } - FilterRange &operator=(FilterRange &&v) { - p_range = move(v.p_range); - p_pred = move(v.p_pred); + FilterRange &operator=(FilterRange &&__v) { + __range = move(__v.__range); + __pred = move(__v.__pred); advance_valid(); return *this; } - bool empty() const { return p_range.empty(); } + bool empty() const { return __range.empty(); } - bool equals_front(const FilterRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const FilterRange &__r) const { + return __range.equals_front(__r.__range); } bool pop_front() { - bool ret = p_range.pop_front(); + bool __ret = __range.pop_front(); advance_valid(); - return ret; + return __ret; } bool push_front() { - T tmp = p_range; - if (!tmp.push_front()) return false; - while (!pred(tmp.front())) - if (!tmp.push_front()) + _T __tmp = __range; + if (!__tmp.push_front()) return false; + while (!pred(__tmp.front())) + if (!__tmp.push_front()) return false; - p_range = tmp; + __range = __tmp; return true; } - RangeReference front() const { return p_range.front(); } + octa::RangeReference<_T> front() const { return __range.front(); } }; - template - FilterRange filter(R range, P pred) { - return FilterRange(range, pred); + template + FilterRange<_R> filter(_R __range, _P __pred) { + return octa::FilterRange<_R>(__range, __pred); } } diff --git a/octa/array.h b/octa/array.h index 9b5ae45..106abc3 100644 --- a/octa/array.h +++ b/octa/array.h @@ -13,55 +13,55 @@ #include "octa/string.h" namespace octa { - template + template struct Array { - typedef size_t SizeType; - typedef ptrdiff_t DiffType; - typedef T ValType; - typedef T &RefType; - typedef const T &ConstRefType; - typedef T *PtrType; - typedef const T *ConstPtrType; - typedef PointerRange< T> RangeType; - typedef PointerRange ConstRangeType; + typedef size_t SizeType; + typedef ptrdiff_t DiffType; + typedef _T ValType; + typedef _T &RefType; + typedef const _T &ConstRefType; + typedef _T *PtrType; + typedef const _T *ConstPtrType; + typedef PointerRange< _T> RangeType; + typedef PointerRange ConstRangeType; - T &operator[](size_t i) { return p_buf[i]; } - const T &operator[](size_t i) const { return p_buf[i]; } + _T &operator[](size_t __i) { return __buf[__i]; } + const _T &operator[](size_t __i) const { return __buf[__i]; } - T &at(size_t i) { return p_buf[i]; } - const T &at(size_t i) const { return p_buf[i]; } + _T &at(size_t __i) { return __buf[__i]; } + const _T &at(size_t __i) const { return __buf[__i]; } - T &front() { return p_buf[0]; } - const T &front() const { return p_buf[0]; } + _T &front() { return __buf[0]; } + const _T &front() const { return __buf[0]; } - T &back() { return p_buf[(N > 0) ? (N - 1) : 0]; } - const T &back() const { return p_buf[(N > 0) ? (N - 1) : 0]; } + _T &back() { return __buf[(_N > 0) ? (_N - 1) : 0]; } + const _T &back() const { return __buf[(_N > 0) ? (_N - 1) : 0]; } - size_t size() const { return N; } + size_t size() const { return _N; } - bool empty() const { return N == 0; } + bool empty() const { return _N == 0; } - bool in_range(size_t idx) { return idx < N; } - bool in_range(int idx) { return idx >= 0 && size_t(idx) < N; } - bool in_range(const T *ptr) { - return ptr >= &p_buf[0] && ptr < &p_buf[N]; + bool in_range(size_t __idx) { return __idx < _N; } + bool in_range(int __idx) { return __idx >= 0 && size_t(__idx) < _N; } + bool in_range(const _T *__ptr) { + return __ptr >= &__buf[0] && __ptr < &__buf[_N]; } - T *data() { return p_buf; } - const T *data() const { return p_buf; } + _T *data() { return __buf; } + const _T *data() const { return __buf; } RangeType each() { - return PointerRange(p_buf, p_buf + N); + return octa::PointerRange<_T>(__buf, __buf + _N); } ConstRangeType each() const { - return PointerRange(p_buf, p_buf + N); + return octa::PointerRange(__buf, __buf + _N); } - void swap(Array &v) { - swap_ranges(each(), v.each()); + void swap(Array &__v) { + octa::swap_ranges(each(), __v.each()); } - T p_buf[(N > 0) ? N : 1]; + _T __buf[(_N > 0) ? _N : 1]; }; } diff --git a/octa/atomic.h b/octa/atomic.h index d561730..39dbfec 100644 --- a/octa/atomic.h +++ b/octa/atomic.h @@ -22,424 +22,51 @@ namespace octa { seq_cst }; - template + template struct __OctaAtomicBase { __OctaAtomicBase() {} - explicit __OctaAtomicBase(T v): value(v) {} - T value; + explicit __OctaAtomicBase(_T __v): __value(__v) {} + _T __value; }; - template T __octa_atomic_create(); + template _T __octa_atomic_create(); - template - EnableIfvalue = __octa_atomic_create()), char> + template + EnableIfvalue = __octa_atomic_create<_U>()), char> __octa_test_atomic_assignable(int); - template + template int __octa_test_atomic_assignable(...); - template + template struct __OctaCanAtomicAssign { static constexpr bool value - = (sizeof(__octa_test_atomic_assignable(1)) == sizeof(char)); + = (sizeof(__octa_test_atomic_assignable<_T, _U>(1)) == sizeof(char)); }; - template + template static inline EnableIf< - __OctaCanAtomicAssign *, T>::value - > __octa_atomic_init(volatile __OctaAtomicBase *a, T v) { - a->value = v; + __OctaCanAtomicAssign *, _T>::value + > __octa_atomic_init(volatile __OctaAtomicBase<_T> *__a, _T __v) { + __a->__value = __v; } - template + template static inline EnableIf< - !__OctaCanAtomicAssign *, T>::value && - __OctaCanAtomicAssign< __OctaAtomicBase *, T>::value - > __octa_atomic_init(volatile __OctaAtomicBase *a, T v) { - volatile char *to = (volatile char *)(&a->value); - volatile char *end = to + sizeof(T); - char *from = (char *)(&v); - while (to != end) *to++ =*from++; + !__OctaCanAtomicAssign *, _T>::value && + __OctaCanAtomicAssign< __OctaAtomicBase<_T> *, _T>::value + > __octa_atomic_init(volatile __OctaAtomicBase<_T> *__a, _T __v) { + volatile char *__to = (volatile char *)(&__a->__value); + volatile char *__end = __to + sizeof(_T); + char *__from = (char *)(&__v); + while (__to != __end) *__to++ =*__from++; } - template - static inline void __octa_atomic_init(__OctaAtomicBase *a, T v) { - a->value = v; + template + static inline void __octa_atomic_init(__OctaAtomicBase<_T> *__a, _T __v) { + __a->__value = __v; } - /* MSVC support - * - * untested, might not work - * - * reference: https://github.com/openvswitch/ovs/blob/master/lib/ovs-atomic-msvc.h - */ - -#ifdef _MSC_VER - -/* MSVC support is disabled for now */ -#if 0 -#define ATOMIC_BOOL_LOCK_FREE 2 -#define ATOMIC_CHAR_LOCK_FREE 2 -#define ATOMIC_CHAR16_T_LOCK_FREE 2 -#define ATOMIC_CHAR32_T_LOCK_FREE 2 -#define ATOMIC_WCHAR_T_LOCK_FREE 2 -#define ATOMIC_SHORT_LOCK_FREE 2 -#define ATOMIC_INT_LOCK_FREE 2 -#define ATOMIC_LONG_LOCK_FREE 2 -#define ATOMIC_LLONG_LOCK_FREE 2 -#define ATOMIC_POINTER_LOCK_FREE 2 - - static inline void __octa_atomic_thread_fence(MemoryOrder ord) { - if (ord > MemoryOrder::consume) { - _ReadWriteBarrier(); - if (ord == MemoryOrder::seq_cst) { - MemoryBarrier(); - _ReadWriteBarrier(); - } - } - } - - static inline void __octa_atomic_signal_fence(MemoryOrder ord) { - if (ord > MemoryOrder::consume) _ReadWriteBarrier(); - } - - static inline bool __octa_atomic_is_lock_free(size_t size) { - return size <= sizeof(void *); - } - - template - struct __OctaMsvcAtomicStore; - - template - struct __OctaMsvcAtomicStore { - static inline void store(volatile T *dst, T src, MemoryOrder ord) { - if (ord == MemoryOrder::seq_cst) - InterlockedExchange8((volatile int8_t *)dst, (int8_t)src); - else *dst = src; - } - }; - - template - struct __OctaMsvcAtomicStore { - static inline void store(volatile T *dst, T src, MemoryOrder ord) { - if (ord == MemoryOrder::seq_cst) - InterlockedExchange16((volatile int16_t *)dst, (int16_t)src); - else *dst = src; - } - }; - - template - struct __OctaMsvcAtomicStore { - static inline void store(volatile T *dst, T src, MemoryOrder ord) { - if (ord == MemoryOrder::seq_cst) - InterlockedExchange((volatile int32_t *)dst, (int32_t)src); - else *dst = src; - } - }; - - template - struct __OctaMsvcAtomicStore { - static inline void store(volatile T *dst, T src, MemoryOrder ord) { - if (ord == MemoryOrder::relaxed) - InterlockedExchangeNoFence64((volatile int64_t *)dst, (int64_t)src); - else - InterlockedExchange64((volatile int64_t *)dst, (int64_t)src); - } - }; - - template - static inline void __octa_atomic_store(volatile __OctaAtomicBase *a, - T v, MemoryOrder ord) { - __OctaMsvcAtomicStore::store(&a->value, v, ord); - } - - template - static inline void __octa_atomic_store(__OctaAtomicBase *a, - T v, MemoryOrder ord) { - __OctaMsvcAtomicStore::store(&a->value, v, ord); - } - - template - struct __OctaMsvcAtomicLoad; - - template - struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) { *dst = *src; } - }; - - template - struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) { *dst = *src; } - }; - - template - struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) { *dst = *src; } - }; - - template - struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) { -#pragma warning(push) -#pragma warning(disable:4047) - *dst = InterlockedOr64((volatile int64_t *)(src), 0); -#pragma warning(pop) - } - }; - - template - static inline T __octa_atomic_load(volatile __OctaAtomicBase *a, - MemoryOrder ord) { - T r; - __OctaMsvcAtomicLoad::load(&a->value, &r); - return r; - } - - template - static inline T __octa_atomic_load(__OctaAtomicBase *a, - MemoryOrder ord) { - T r; - __OctaMsvcAtomicLoad::load(&a->value, &r); - return r; - } - - template - struct __OctaMsvcAtomicExchange; - - template - struct __OctaMsvcAtomicExchange { - static inline void exchange(volatile T *dst, T src, T *ret) { - *ret = InterlockedExchange8((volatile int8_t *)dst, (int8_t)src); - } - }; - - template - struct __OctaMsvcAtomicExchange { - static inline void exchange(volatile T *dst, T src, T *ret) { - *ret = InterlockedExchange16((volatile int16_t *)dst, (int16_t)src); - } - }; - - template - struct __OctaMsvcAtomicExchange { - static inline void exchange(volatile T *dst, T src, T *ret) { - *ret = InterlockedExchange((volatile int32_t *)dst, (int32_t)src); - } - }; - - template - struct __OctaMsvcAtomicExchange { - static inline void exchange(volatile T *dst, T src, T *ret) { - *ret = InterlockedExchange64((volatile int64_t *)dst, (int64_t)src); - } - }; - - template - static inline T __octa_atomic_exchange(volatile __OctaAtomicBase *a, - T v, memory_order) { - T r; - __OctaMsvcAtomicExchange::exchange(&a->value, v, &r); - return r; - } - - template - static inline T __octa_atomic_exchange(__OctaAtomicBase *a, - T v, memory_order) { - T r; - __OctaMsvcAtomicExchange::exchange(&a->value, v, &r); - return r; - } - - template - struct __OctaMsvcAtomicCompareExchange; - - template - struct __OctaMsvcAtomicCompareExchange { - static inline bool exchange(volatile T *dst, T *exp, T src) { - int8_t prev = _InterlockedCompareExchange8((volatile int8_t *)dst, - (int8_t)src, (int8_t)*exp); - if (prev == (int8_t)*exp) return true; - *exp = (T)prev; return false; - } - }; - - template - struct __OctaMsvcAtomicCompareExchange { - static inline bool exchange(volatile T *dst, T *exp, T src) { - int16_t prev = _InterlockedCompareExchange16((volatile int16_t *)dst, - (int16_t)src, (int16_t)*exp); - if (prev == (int16_t)*exp) return true; - *exp = (T)prev; return false; - } - }; - - template - struct __OctaMsvcAtomicCompareExchange { - static inline bool exchange(volatile T *dst, T *exp, T src) { - int32_t prev = _InterlockedCompareExchange((volatile int32_t *)dst, - (int32_t)src, (int32_t)*exp); - if (prev == (int32_t)*exp) return true; - *exp = (T)prev; return false; - } - }; - - template - struct __OctaMsvcAtomicCompareExchange { - static inline bool exchange(volatile T *dst, T *exp, T src) { - int64_t prev = _InterlockedCompareExchange64((volatile int64_t *)dst, - (int64_t)src, (int64_t)*exp); - if (prev == (int64_t)*exp) return true; - *exp = (T)prev; return false; - } - }; - - template - static inline bool __octa_atomic_compare_exchange_strong( - volatile __OctaAtomicBase *a, T *expected, T v, - memory_order, memory_order - ) { - return __OctaMsvcAtomicCompareExchange::exchange(&a->value, expected, v); - } - - template - static inline bool __octa_atomic_compare_exchange_strong( - __OctaAtomicBase *a, T *expected, T v, - memory_order, memory_order - ) { - return __OctaMsvcAtomicCompareExchange::exchange(&a->value, expected, v); - } - - template - static inline bool __octa_atomic_compare_exchange_weak( - volatile __OctaAtomicBase *a, T *expected, T v, - memory_order, memory_order - ) { - return __OctaMsvcAtomicCompareExchange::exchange(&a->value, expected, v); - } - - template - static inline bool __octa_atomic_compare_exchange_weak( - __OctaAtomicBase *a, T *expected, T v, - memory_order, memory_order - ) { - return __OctaMsvcAtomicCompareExchange::exchange(&a->value, expected, v); - } - -#define __OCTA_MSVC_ATOMIC_FETCH_OP(opn, dst, val, ret) \ - if (sizeof(*dst) == 1) { \ - *(ret) = _InterlockedExchange##opn##8((volatile int8_t *)dst, (int8_t)val); \ - } else if (sizeof(*dst) == 2) { \ - *(ret) = _InterlockedExchange##opn##16((volatile int16_t *)dst, (int16_t)val); \ - } else if (sizeof(*dst) == 4) { \ - *(ret) = InterlockedExchange##opn((volatile int32_t *)dst, (int32_t)val); \ - } else if (sizeof(*dst) == 8) { \ - *(ret) = _InterlockedExchange##opn##64((volatile int64_t *)dst, (int64_t)val); \ - } else { \ - abort(); \ - } - - template - static inline T __octa_atomic_fetch_add(volatile __OctaAtomicBase *a, - U d, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Add, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_add(__OctaAtomicBase *a, - U d, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Add, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_sub(volatile __OctaAtomicBase *a, - U d, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Sub, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_sub(__OctaAtomicBase *a, - U d, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Sub, &a->value, d, &r); - return r; - } - -#undef __OCTA_MSVC_ATOMIC_FETCH_OP - -#define __OCTA_MSVC_ATOMIC_FETCH_OP(opn, dst, val, ret) \ - if (sizeof(*dst) == 1) { \ - *(ret) = Interlocked##opn##8((volatile int8_t *)dst, (int8_t)val); \ - } else if (sizeof(*dst) == 2) { \ - *(ret) = Interlocked##opn##16((volatile int16_t *)dst, (int16_t)val); \ - } else if (sizeof(*dst) == 4) { \ - *(ret) = Interlocked##opn((volatile int32_t *)dst, (int32_t)val); \ - } else if (sizeof(*dst) == 8) { \ - *(ret) = Interlocked##opn##64((volatile int64_t *)dst, (int64_t)val); \ - } else { \ - abort(); \ - } - - template - static inline T __octa_atomic_fetch_and(volatile __OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(And, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_and(__OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(And, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_or(volatile __OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Or, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_or(__OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Or, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_xor(volatile __OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Xor, &a->value, d, &r); - return r; - } - - template - static inline T __octa_atomic_fetch_xor(__OctaAtomicBase *a, - T pattern, memory_order) { - T r; - __OCTA_MSVC_ATOMIC_FETCH_OP(Xor, &a->value, d, &r); - return r; - } - -#undef __OCTA_MSVC_ATOMIC_FETCH_OP -#else -#error No MSVC support right now! -#endif - -#else - /* GCC, Clang support * * libc++ used for reference @@ -458,211 +85,211 @@ namespace octa { #define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE #define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE - static inline constexpr int __octa_to_gcc_order(MemoryOrder ord) { - return ((ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED : - ((ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE : - ((ord == MemoryOrder::release) ? __ATOMIC_RELEASE : - ((ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST : - ((ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQ_REL : + static inline constexpr int __octa_to_gcc_order(MemoryOrder __ord) { + return ((__ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED : + ((__ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE : + ((__ord == MemoryOrder::release) ? __ATOMIC_RELEASE : + ((__ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST : + ((__ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQ_REL : __ATOMIC_CONSUME))))); } - static inline constexpr int __octa_to_gcc_failure_order(MemoryOrder ord) { - return ((ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED : - ((ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE : - ((ord == MemoryOrder::release) ? __ATOMIC_RELAXED : - ((ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST : - ((ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQUIRE : + static inline constexpr int __octa_to_gcc_failure_order(MemoryOrder __ord) { + return ((__ord == MemoryOrder::relaxed) ? __ATOMIC_RELAXED : + ((__ord == MemoryOrder::acquire) ? __ATOMIC_ACQUIRE : + ((__ord == MemoryOrder::release) ? __ATOMIC_RELAXED : + ((__ord == MemoryOrder::seq_cst) ? __ATOMIC_SEQ_CST : + ((__ord == MemoryOrder::acq_rel) ? __ATOMIC_ACQUIRE : __ATOMIC_CONSUME))))); } - static inline void __octa_atomic_thread_fence(MemoryOrder ord) { - __atomic_thread_fence(__octa_to_gcc_order(ord)); + static inline void __octa_atomic_thread_fence(MemoryOrder __ord) { + __atomic_thread_fence(__octa_to_gcc_order(__ord)); } - static inline void __octa_atomic_signal_fence(MemoryOrder ord) { - __atomic_signal_fence(__octa_to_gcc_order(ord)); + static inline void __octa_atomic_signal_fence(MemoryOrder __ord) { + __atomic_signal_fence(__octa_to_gcc_order(__ord)); } - static inline bool __octa_atomic_is_lock_free(size_t size) { + static inline bool __octa_atomic_is_lock_free(size_t __size) { /* return __atomic_is_lock_free(size, 0); cannot be used on some platforms */ - return size <= sizeof(void *); + return __size <= sizeof(void *); } - template - static inline void __octa_atomic_store(volatile __OctaAtomicBase *a, - T v, MemoryOrder ord) { - __atomic_store(&a->value, &v, __octa_to_gcc_order(ord)); + template + static inline void __octa_atomic_store(volatile __OctaAtomicBase<_T> *__a, + _T __v, MemoryOrder __ord) { + __atomic_store(&__a->__value, &__v, __octa_to_gcc_order(__ord)); } - template - static inline void __octa_atomic_store(__OctaAtomicBase *a, - T v, MemoryOrder ord) { - __atomic_store(&a->value, &v, __octa_to_gcc_order(ord)); + template + static inline void __octa_atomic_store(__OctaAtomicBase<_T> *__a, + _T __v, MemoryOrder __ord) { + __atomic_store(&__a->__value, &__v, __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_load(volatile __OctaAtomicBase *a, - MemoryOrder ord) { - T r; - __atomic_load(&a->value, &r, __octa_to_gcc_order(ord)); - return r; + template + static inline _T __octa_atomic_load(volatile __OctaAtomicBase<_T> *__a, + MemoryOrder __ord) { + _T __r; + __atomic_load(&__a->__value, &__r, __octa_to_gcc_order(__ord)); + return __r; } - template - static inline T __octa_atomic_load(__OctaAtomicBase *a, - MemoryOrder ord) { - T r; - __atomic_load(&a->value, &r, __octa_to_gcc_order(ord)); - return r; + template + static inline _T __octa_atomic_load(__OctaAtomicBase<_T> *__a, + MemoryOrder __ord) { + _T __r; + __atomic_load(&__a->__value, &__r, __octa_to_gcc_order(__ord)); + return __r; } - template - static inline T __octa_atomic_exchange(volatile __OctaAtomicBase *a, - T v, MemoryOrder ord) { - T r; - __atomic_exchange(&a->value, &v, &r, __octa_to_gcc_order(ord)); - return r; + template + static inline _T __octa_atomic_exchange(volatile __OctaAtomicBase<_T> *__a, + _T __v, MemoryOrder __ord) { + _T __r; + __atomic_exchange(&__a->__value, &__v, &__r, __octa_to_gcc_order(__ord)); + return __r; } - template - static inline T __octa_atomic_exchange(__OctaAtomicBase *a, - T v, MemoryOrder ord) { - T r; - __atomic_exchange(&a->value, &v, &r, __octa_to_gcc_order(ord)); - return r; + template + static inline _T __octa_atomic_exchange(__OctaAtomicBase<_T> *__a, + _T __v, MemoryOrder __ord) { + _T __r; + __atomic_exchange(&__a->__value, &__v, &__r, __octa_to_gcc_order(__ord)); + return __r; } - template + template static inline bool __octa_atomic_compare_exchange_strong( - volatile __OctaAtomicBase *a, T *expected, T v, - MemoryOrder success, MemoryOrder failure + volatile __OctaAtomicBase<_T> *__a, _T *__expected, _T __v, + MemoryOrder __success, MemoryOrder __failure ) { - return __atomic_compare_exchange(&a->value, expected, &v, false, - __octa_to_gcc_order(success), __octa_to_gcc_failure_order(failure)); + return __atomic_compare_exchange(&__a->__value, __expected, &__v, false, + __octa_to_gcc_order(__success), __octa_to_gcc_failure_order(__failure)); } - template + template static inline bool __octa_atomic_compare_exchange_strong( - __OctaAtomicBase *a, T *expected, T v, - MemoryOrder success, MemoryOrder failure + __OctaAtomicBase<_T> *__a, _T *__expected, _T __v, + MemoryOrder __success, MemoryOrder __failure ) { - return __atomic_compare_exchange(&a->value, expected, &v, false, - __octa_to_gcc_order(success), __octa_to_gcc_failure_order(failure)); + return __atomic_compare_exchange(&__a->__value, __expected, &__v, false, + __octa_to_gcc_order(__success), __octa_to_gcc_failure_order(__failure)); } - template + template static inline bool __octa_atomic_compare_exchange_weak( - volatile __OctaAtomicBase *a, T *expected, T v, - MemoryOrder success, MemoryOrder failure + volatile __OctaAtomicBase<_T> *__a, _T *__expected, _T __v, + MemoryOrder __success, MemoryOrder __failure ) { - return __atomic_compare_exchange(&a->value, expected, &v, true, - __octa_to_gcc_order(success), __octa_to_gcc_failure_order(failure)); + return __atomic_compare_exchange(&__a->__value, __expected, &__v, true, + __octa_to_gcc_order(__success), __octa_to_gcc_failure_order(__failure)); } - template + template static inline bool __octa_atomic_compare_exchange_weak( - __OctaAtomicBase *a, T *expected, T v, - MemoryOrder success, MemoryOrder failure + __OctaAtomicBase<_T> *__a, _T *__expected, _T __v, + MemoryOrder __success, MemoryOrder __failure ) { - return __atomic_compare_exchange(&a->value, expected, &v, true, - __octa_to_gcc_order(success), __octa_to_gcc_failure_order(failure)); + return __atomic_compare_exchange(&__a->__value, __expected, &__v, true, + __octa_to_gcc_order(__success), __octa_to_gcc_failure_order(__failure)); } - template + template struct __OctaSkipAmt { static constexpr size_t value = 1; }; - template - struct __OctaSkipAmt { static constexpr size_t value = sizeof(T); }; + template + struct __OctaSkipAmt<_T *> { static constexpr size_t value = sizeof(_T); }; - template struct __OctaSkipAmt {}; - template struct __OctaSkipAmt {}; + template struct __OctaSkipAmt<_T[]> {}; + template struct __OctaSkipAmt<_T[_N]> {}; - template - static inline T __octa_atomic_fetch_add(volatile __OctaAtomicBase *a, - U d, MemoryOrder ord) { - return __atomic_fetch_add(&a->value, d * __OctaSkipAmt::value, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_add(volatile __OctaAtomicBase<_T> *__a, + _U __d, MemoryOrder __ord) { + return __atomic_fetch_add(&__a->__value, __d * __OctaSkipAmt<_T>::value, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_add(__OctaAtomicBase *a, - U d, MemoryOrder ord) { - return __atomic_fetch_add(&a->value, d * __OctaSkipAmt::value, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_add(__OctaAtomicBase<_T> *__a, + _U __d, MemoryOrder __ord) { + return __atomic_fetch_add(&__a->__value, __d * __OctaSkipAmt<_T>::value, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_sub(volatile __OctaAtomicBase *a, - U d, MemoryOrder ord) { - return __atomic_fetch_sub(&a->value, d * __OctaSkipAmt::value, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_sub(volatile __OctaAtomicBase<_T> *__a, + _U __d, MemoryOrder __ord) { + return __atomic_fetch_sub(&__a->__value, __d * __OctaSkipAmt<_T>::value, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_sub(__OctaAtomicBase *a, - U d, MemoryOrder ord) { - return __atomic_fetch_sub(&a->value, d * __OctaSkipAmt::value, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_sub(__OctaAtomicBase<_T> *__a, + _U __d, MemoryOrder __ord) { + return __atomic_fetch_sub(&__a->__value, __d * __OctaSkipAmt<_T>::value, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_and(volatile __OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_and(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_and(volatile __OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_and(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_and(__OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_and(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_and(__OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_and(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_or(volatile __OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_or(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_or(volatile __OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_or(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_or(__OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_or(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_or(__OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_or(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_xor(volatile __OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_xor(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_xor(volatile __OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_xor(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } - template - static inline T __octa_atomic_fetch_xor(__OctaAtomicBase *a, - T pattern, MemoryOrder ord) { - return __atomic_fetch_xor(&a->value, pattern, - __octa_to_gcc_order(ord)); + template + static inline _T __octa_atomic_fetch_xor(__OctaAtomicBase<_T> *__a, + _T __pattern, MemoryOrder __ord) { + return __atomic_fetch_xor(&__a->__value, __pattern, + __octa_to_gcc_order(__ord)); } #else # error Unsupported compiler -#endif #endif - template inline T kill_dependency(T v) { - return v; + template inline _T kill_dependency(_T __v) { + return __v; } - template::value && !IsSame::value> + template::value && + !octa::IsSame<_T, bool>::value> struct __OctaAtomic { - mutable __OctaAtomicBase p_a; + mutable __OctaAtomicBase<_T> __a; __OctaAtomic() = default; - constexpr __OctaAtomic(T v): p_a(v) {} + constexpr __OctaAtomic(_T __v): __a(__v) {} __OctaAtomic(const __OctaAtomic &) = delete; @@ -670,584 +297,627 @@ namespace octa { __OctaAtomic &operator=(const __OctaAtomic &) volatile = delete; bool is_lock_free() const volatile { - return __octa_atomic_is_lock_free(sizeof(T)); + return __octa_atomic_is_lock_free(sizeof(_T)); } bool is_lock_free() const { - return __octa_atomic_is_lock_free(sizeof(T)); + return __octa_atomic_is_lock_free(sizeof(_T)); } - void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - __octa_atomic_store(&p_a, v, ord); + void store(_T __v, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + __octa_atomic_store(&__a, __v, __ord); } - void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) { - __octa_atomic_store(&p_a, v, ord); + void store(_T __v, MemoryOrder __ord = MemoryOrder::seq_cst) { + __octa_atomic_store(&__a, __v, __ord); } - T load(MemoryOrder ord = MemoryOrder::seq_cst) const volatile { - return __octa_atomic_load(&p_a, ord); + _T load(MemoryOrder __ord = MemoryOrder::seq_cst) const volatile { + return __octa_atomic_load(&__a, __ord); } - T load(MemoryOrder ord = MemoryOrder::seq_cst) const { - return __octa_atomic_load(&p_a, ord); + _T load(MemoryOrder __ord = MemoryOrder::seq_cst) const { + return __octa_atomic_load(&__a, __ord); } - operator T() const volatile { return load(); } - operator T() const { return load(); } + operator _T() const volatile { return load(); } + operator _T() const { return load(); } - T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_exchange(&p_a, v, ord); + _T exchange(_T __v, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_exchange(&__a, __v, __ord); } - T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_exchange(&p_a, v, ord); + _T exchange(_T __v, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_exchange(&__a, __v, __ord); } - bool compare_exchange_weak(T &e, T v, MemoryOrder s, MemoryOrder f) - volatile { - return __octa_atomic_compare_exchange_weak(&p_a, &e, v, s, f); + bool compare_exchange_weak(_T &__e, _T __v, MemoryOrder __s, + MemoryOrder __f) volatile { + return __octa_atomic_compare_exchange_weak(&__a, &__e, __v, + __s, __f); } - bool compare_exchange_weak(T& e, T v, MemoryOrder s, MemoryOrder f) { - return __octa_atomic_compare_exchange_weak(&p_a, &e, v, s, f); + bool compare_exchange_weak(_T &__e, _T __v, MemoryOrder __s, + MemoryOrder __f) { + return __octa_atomic_compare_exchange_weak(&__a, &__e, __v, + __s, __f); } - bool compare_exchange_strong(T& e, T v, MemoryOrder s, MemoryOrder f) - volatile { - return __octa_atomic_compare_exchange_strong(&p_a, &e, v, s, f); + bool compare_exchange_strong(_T &__e, _T __v, MemoryOrder __s, + MemoryOrder __f) volatile { + return __octa_atomic_compare_exchange_strong(&__a, &__e, __v, + __s, __f); } - bool compare_exchange_strong(T& e, T v, MemoryOrder s, MemoryOrder f) { - return __octa_atomic_compare_exchange_strong(&p_a, &e, v, s, f); + bool compare_exchange_strong(_T &__e, _T __v, MemoryOrder __s, + MemoryOrder __f) { + return __octa_atomic_compare_exchange_strong(&__a, &__e, __v, + __s, __f); } - bool compare_exchange_weak(T& e, T v, MemoryOrder ord + bool compare_exchange_weak(_T &__e, _T __v, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_compare_exchange_weak(&p_a, &e, v, ord, ord); + return __octa_atomic_compare_exchange_weak(&__a, &__e, __v, + __ord, __ord); } - bool compare_exchange_weak(T& e, T v, MemoryOrder ord + bool compare_exchange_weak(_T &__e, _T __v, MemoryOrder __ord = MemoryOrder::seq_cst) { - return __octa_atomic_compare_exchange_weak(&p_a, &e, v, ord, ord); + return __octa_atomic_compare_exchange_weak(&__a, &__e, __v, + __ord, __ord); } - bool compare_exchange_strong(T& e, T v, MemoryOrder ord + bool compare_exchange_strong(_T &__e, _T __v, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_compare_exchange_strong(&p_a, &e, v, ord, ord); + return __octa_atomic_compare_exchange_strong(&__a, &__e, + __v, __ord, __ord); } - bool compare_exchange_strong(T& e, T v, MemoryOrder ord + bool compare_exchange_strong(_T &__e, _T __v, MemoryOrder __ord = MemoryOrder::seq_cst) { - return __octa_atomic_compare_exchange_strong(&p_a, &e, v, ord, ord); + return __octa_atomic_compare_exchange_strong(&__a, &__e, __v, + __ord, __ord); } }; - template - struct __OctaAtomic: __OctaAtomic { - typedef __OctaAtomic base_t; + template + struct __OctaAtomic<_T, true>: __OctaAtomic<_T, false> { + typedef __OctaAtomic<_T, false> _base_t; __OctaAtomic() = default; - constexpr __OctaAtomic(T v): base_t(v) {} + constexpr __OctaAtomic(_T __v): _base_t(__v) {} - T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_add(&this->p_a, op, ord); + _T fetch_add(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_fetch_add(&this->__a, __op, __ord); } - T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_add(&this->p_a, op, ord); + _T fetch_add(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_add(&this->__a, __op, __ord); } - T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_sub(&this->p_a, op, ord); + _T fetch_sub(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_fetch_sub(&this->__a, __op, __ord); } - T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_sub(&this->p_a, op, ord); + _T fetch_sub(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_sub(&this->__a, __op, __ord); } - T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_and(&this->p_a, op, ord); + _T fetch_and(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_fetch_and(&this->__a, __op, __ord); } - T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_and(&this->p_a, op, ord); + _T fetch_and(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_and(&this->__a, __op, __ord); } - T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_or(&this->p_a, op, ord); + _T fetch_or(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_fetch_or(&this->__a, __op, __ord); } - T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_or(&this->p_a, op, ord); + _T fetch_or(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_or(&this->__a, __op, __ord); } - T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_xor(&this->p_a, op, ord); + _T fetch_xor(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_fetch_xor(&this->__a, __op, __ord); } - T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_xor(&this->p_a, op, ord); + _T fetch_xor(_T __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_xor(&this->__a, __op, __ord); } - T operator++(int) volatile { return fetch_add(T(1)); } - T operator++(int) { return fetch_add(T(1)); } - T operator--(int) volatile { return fetch_sub(T(1)); } - T operator--(int) { return fetch_sub(T(1)); } - T operator++( ) volatile { return fetch_add(T(1)) + T(1); } - T operator++( ) { return fetch_add(T(1)) + T(1); } - T operator--( ) volatile { return fetch_sub(T(1)) - T(1); } - T operator--( ) { return fetch_sub(T(1)) - T(1); } + _T operator++(int) volatile { return fetch_add(_T(1)); } + _T operator++(int) { return fetch_add(_T(1)); } + _T operator--(int) volatile { return fetch_sub(_T(1)); } + _T operator--(int) { return fetch_sub(_T(1)); } + _T operator++( ) volatile { return fetch_add(_T(1)) + _T(1); } + _T operator++( ) { return fetch_add(_T(1)) + _T(1); } + _T operator--( ) volatile { return fetch_sub(_T(1)) - _T(1); } + _T operator--( ) { return fetch_sub(_T(1)) - _T(1); } - T operator+=(T op) volatile { return fetch_add(op) + op; } - T operator+=(T op) { return fetch_add(op) + op; } - T operator-=(T op) volatile { return fetch_sub(op) - op; } - T operator-=(T op) { return fetch_sub(op) - op; } - T operator&=(T op) volatile { return fetch_and(op) & op; } - T operator&=(T op) { return fetch_and(op) & op; } - T operator|=(T op) volatile { return fetch_or (op) | op; } - T operator|=(T op) { return fetch_or (op) | op; } - T operator^=(T op) volatile { return fetch_xor(op) ^ op; } - T operator^=(T op) { return fetch_xor(op) ^ op; } + _T operator+=(_T __op) volatile { return fetch_add(__op) + __op; } + _T operator+=(_T __op) { return fetch_add(__op) + __op; } + _T operator-=(_T __op) volatile { return fetch_sub(__op) - __op; } + _T operator-=(_T __op) { return fetch_sub(__op) - __op; } + _T operator&=(_T __op) volatile { return fetch_and(__op) & __op; } + _T operator&=(_T __op) { return fetch_and(__op) & __op; } + _T operator|=(_T __op) volatile { return fetch_or (__op) | __op; } + _T operator|=(_T __op) { return fetch_or (__op) | __op; } + _T operator^=(_T __op) volatile { return fetch_xor(__op) ^ __op; } + _T operator^=(_T __op) { return fetch_xor(__op) ^ __op; } }; - template - struct Atomic: __OctaAtomic { - typedef __OctaAtomic base_t; + template + struct Atomic: __OctaAtomic<_T> { + typedef __OctaAtomic<_T> _base_t; Atomic() = default; - constexpr Atomic(T v): base_t(v) {} + constexpr Atomic(_T __v): _base_t(__v) {} - T operator=(T v) volatile { - base_t::store(v); return v; + _T operator=(_T __v) volatile { + _base_t::store(__v); return __v; } - T operator=(T v) { - base_t::store(v); return v; + _T operator=(_T __v) { + _base_t::store(__v); return __v; } }; - template - struct Atomic: __OctaAtomic { - typedef __OctaAtomic base_t; + template + struct Atomic<_T *>: __OctaAtomic<_T *> { + typedef __OctaAtomic<_T *> _base_t; Atomic() = default; - constexpr Atomic(T *v): base_t(v) {} + constexpr Atomic(_T *__v): _base_t(__v) {} - T *operator=(T *v) volatile { - base_t::store(v); return v; + _T *operator=(_T *__v) volatile { + _base_t::store(__v); return __v; } - T *operator=(T *v) { - base_t::store(v); return v; + _T *operator=(_T *__v) { + _base_t::store(__v); return __v; } - T *fetch_add(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) + _T *fetch_add(ptrdiff_t __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_add(&this->p_a, op, ord); + return __octa_atomic_fetch_add(&this->__a, __op, __ord); } - T *fetch_add(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_add(&this->p_a, op, ord); + _T *fetch_add(ptrdiff_t __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_add(&this->__a, __op, __ord); } - T *fetch_sub(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) + _T *fetch_sub(ptrdiff_t __op, MemoryOrder __ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_fetch_sub(&this->p_a, op, ord); + return __octa_atomic_fetch_sub(&this->__a, __op, __ord); } - T *fetch_sub(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_fetch_sub(&this->p_a, op, ord); + _T *fetch_sub(ptrdiff_t __op, MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_fetch_sub(&this->__a, __op, __ord); } - T *operator++(int) volatile { return fetch_add(1); } - T *operator++(int) { return fetch_add(1); } - T *operator--(int) volatile { return fetch_sub(1); } - T *operator--(int) { return fetch_sub(1); } - T *operator++( ) volatile { return fetch_add(1) + 1; } - T *operator++( ) { return fetch_add(1) + 1; } - T *operator--( ) volatile { return fetch_sub(1) - 1; } - T *operator--( ) { return fetch_sub(1) - 1; } + _T *operator++(int) volatile { return fetch_add(1); } + _T *operator++(int) { return fetch_add(1); } + _T *operator--(int) volatile { return fetch_sub(1); } + _T *operator--(int) { return fetch_sub(1); } + _T *operator++( ) volatile { return fetch_add(1) + 1; } + _T *operator++( ) { return fetch_add(1) + 1; } + _T *operator--( ) volatile { return fetch_sub(1) - 1; } + _T *operator--( ) { return fetch_sub(1) - 1; } - T *operator+=(ptrdiff_t op) volatile { return fetch_add(op) + op; } - T *operator+=(ptrdiff_t op) { return fetch_add(op) + op; } - T *operator-=(ptrdiff_t op) volatile { return fetch_sub(op) - op; } - T *operator-=(ptrdiff_t op) { return fetch_sub(op) - op; } + _T *operator+=(ptrdiff_t __op) volatile { return fetch_add(__op) + __op; } + _T *operator+=(ptrdiff_t __op) { return fetch_add(__op) + __op; } + _T *operator-=(ptrdiff_t __op) volatile { return fetch_sub(__op) - __op; } + _T *operator-=(ptrdiff_t __op) { return fetch_sub(__op) - __op; } }; - template - inline bool atomic_is_lock_free(const volatile Atomic *a) { - return a->is_lock_free(); + template + inline bool atomic_is_lock_free(const volatile Atomic<_T> *__a) { + return __a->is_lock_free(); } - template - inline bool atomic_is_lock_free(const Atomic *a) { - return a->is_lock_free(); + template + inline bool atomic_is_lock_free(const Atomic<_T> *__a) { + return __a->is_lock_free(); } - template - inline void atomic_init(volatile Atomic *a, T v) { - __octa_atomic_init(&a->p_a, v); + template + inline void atomic_init(volatile Atomic<_T> *__a, _T __v) { + __octa_atomic_init(&__a->__a, __v); } - template - inline void atomic_init(Atomic *a, T v) { - __octa_atomic_init(&a->p_a, v); + template + inline void atomic_init(Atomic<_T> *__a, _T __v) { + __octa_atomic_init(&__a->__a, __v); } - template - inline void atomic_store(volatile Atomic *a, T v) { - a->store(v); + template + inline void atomic_store(volatile Atomic<_T> *__a, _T __v) { + __a->store(__v); } - template - inline void atomic_store(Atomic *a, T v) { - a->store(v); + template + inline void atomic_store(Atomic<_T> *__a, _T __v) { + __a->store(__v); } - template - inline void atomic_store_explicit(volatile Atomic *a, T v, - MemoryOrder ord) { - a->store(v, ord); + template + inline void atomic_store_explicit(volatile Atomic<_T> *__a, _T __v, + MemoryOrder __ord) { + __a->store(__v, __ord); } - template - inline void atomic_store_explicit(Atomic *a, T v, MemoryOrder ord) { - a->store(v, ord); + template + inline void atomic_store_explicit(Atomic<_T> *__a, _T __v, + MemoryOrder __ord) { + __a->store(__v, __ord); } - template - inline T atomic_load(const volatile Atomic *a) { - return a->load(); + template + inline _T atomic_load(const volatile Atomic<_T> *__a) { + return __a->load(); } - template - inline T atomic_load(const Atomic *a) { - return a->load(); + template + inline _T atomic_load(const Atomic<_T> *__a) { + return __a->load(); } - template - inline T atomic_load_explicit(const volatile Atomic *a, - MemoryOrder ord) { - return a->load(ord); + template + inline _T atomic_load_explicit(const volatile Atomic<_T> *__a, + MemoryOrder __ord) { + return __a->load(__ord); } - template - inline T atomic_load_explicit(const Atomic *a, MemoryOrder ord) { - return a->load(ord); + template + inline _T atomic_load_explicit(const Atomic<_T> *__a, MemoryOrder __ord) { + return __a->load(__ord); } - template - inline T atomic_exchange(volatile Atomic *a, T v) { - return a->exchange(v); + template + inline _T atomic_exchange(volatile Atomic<_T> *__a, _T __v) { + return __a->exchange(__v); } - template - inline T atomic_exchange(Atomic *a, T v) { - return a->exchange(v); + template + inline _T atomic_exchange(Atomic<_T> *__a, _T __v) { + return __a->exchange(__v); } - template - inline T atomic_exchange_explicit(volatile Atomic *a, T v, - MemoryOrder ord) { - return a->exchange(v, ord); + template + inline _T atomic_exchange_explicit(volatile Atomic<_T> *__a, _T __v, + MemoryOrder __ord) { + return __a->exchange(__v, __ord); } - template - inline T atomic_exchange_explicit(Atomic *a, T v, MemoryOrder ord) { - return a->exchange(v, ord); + template + inline _T atomic_exchange_explicit(Atomic<_T> *__a, _T __v, + MemoryOrder __ord) { + return __a->exchange(__v, __ord); } - template - inline bool atomic_compare_exchange_weak(volatile Atomic *a, T *e, T v) { - return a->compare_exchange_weak(*e, v); + template + inline bool atomic_compare_exchange_weak(volatile Atomic<_T> *__a, + _T *__e, _T __v) { + return __a->compare_exchange_weak(*__e, __v); } - template - inline bool atomic_compare_exchange_weak(Atomic *a, T *e, T v) { - return a->compare_exchange_weak(*e, v); + template + inline bool atomic_compare_exchange_weak(Atomic<_T> *__a, _T *__e, _T __v) { + return __a->compare_exchange_weak(*__e, __v); } - template - inline bool atomic_compare_exchange_strong(volatile Atomic *a, T *e, T v) { - return a->compare_exchange_strong(*e, v); + template + inline bool atomic_compare_exchange_strong(volatile Atomic<_T> *__a, + _T *__e, _T __v) { + return __a->compare_exchange_strong(*__e, __v); } - template - inline bool atomic_compare_exchange_strong(Atomic *a, T *e, T v) { - return a->compare_exchange_strong(*e, v); + template + inline bool atomic_compare_exchange_strong(Atomic<_T> *__a, _T *__e, _T __v) { + return __a->compare_exchange_strong(*__e, __v); } - template - inline bool atomic_compare_exchange_weak_explicit(volatile Atomic *a, - T *e, T v, - MemoryOrder s, - MemoryOrder f) { - return a->compare_exchange_weak(*e, v, s, f); + template + inline bool atomic_compare_exchange_weak_explicit(volatile Atomic<_T> *__a, + _T *__e, _T __v, + MemoryOrder __s, + MemoryOrder __f) { + return __a->compare_exchange_weak(*__e, __v, __s, __f); } - template - inline bool atomic_compare_exchange_weak_explicit(Atomic *a, T *e, T v, - MemoryOrder s, - MemoryOrder f) { - return a->compare_exchange_weak(*e, v, s, f); + template + inline bool atomic_compare_exchange_weak_explicit(Atomic<_T> *__a, _T *__e, + _T __v, + MemoryOrder __s, + MemoryOrder __f) { + return __a->compare_exchange_weak(*__e, __v, __s, __f); } - template - inline bool atomic_compare_exchange_strong_explicit(volatile Atomic *a, - T *e, T v, - MemoryOrder s, - MemoryOrder f) { - return a->compare_exchange_strong(*e, v, s, f); + template + inline bool atomic_compare_exchange_strong_explicit(volatile Atomic<_T> *__a, + _T *__e, _T __v, + MemoryOrder __s, + MemoryOrder __f) { + return __a->compare_exchange_strong(*__e, __v, __s, __f); } - template - inline bool atomic_compare_exchange_strong_explicit(Atomic *a, T *e, T v, - MemoryOrder s, - MemoryOrder f) { - return a->compare_exchange_strong(*e, v, s, f); + template + inline bool atomic_compare_exchange_strong_explicit(Atomic<_T> *__a, _T *__e, + _T __v, + MemoryOrder __s, + MemoryOrder __f) { + return __a->compare_exchange_strong(*__e, __v, __s, __f); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add(volatile Atomic *a, T op) { - return a->fetch_add(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_add(volatile Atomic<_T> *__a, _T __op) { + return __a->fetch_add(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add(Atomic *a, T op) { - return a->fetch_add(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_add(Atomic<_T> *__a, _T __op) { + return __a->fetch_add(__op); } - template - inline T *atomic_fetch_add(volatile Atomic *a, ptrdiff_t op) { - return a->fetch_add(op); + template + inline _T *atomic_fetch_add(volatile Atomic<_T *> *__a, ptrdiff_t __op) { + return __a->fetch_add(__op); } - template - inline T *atomic_fetch_add(Atomic *a, ptrdiff_t op) { - return a->fetch_add(op); + template + inline _T *atomic_fetch_add(Atomic<_T *> *__a, ptrdiff_t __op) { + return __a->fetch_add(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add_explicit(volatile Atomic *a, T op, MemoryOrder ord) { - return a->fetch_add(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_add_explicit(volatile Atomic<_T> *__a, _T __op, + MemoryOrder __ord) { + return __a->fetch_add(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add_explicit(Atomic *a, T op, MemoryOrder ord) { - return a->fetch_add(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_add_explicit(Atomic<_T> *__a, _T __op, MemoryOrder __ord) { + return __a->fetch_add(__op, __ord); } - template - inline T *atomic_fetch_add_explicit(volatile Atomic *a, ptrdiff_t op, - MemoryOrder ord) { - return a->fetch_add(op, ord); + template + inline _T *atomic_fetch_add_explicit(volatile Atomic<_T *> *__a, + ptrdiff_t __op, + MemoryOrder __ord) { + return __a->fetch_add(__op, __ord); } - template - inline T *atomic_fetch_add_explicit(Atomic *a, ptrdiff_t op, - MemoryOrder ord) { - return a->fetch_add(op, ord); + template + inline _T *atomic_fetch_add_explicit(Atomic<_T *> *__a, ptrdiff_t __op, + MemoryOrder __ord) { + return __a->fetch_add(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub(volatile Atomic *a, T op) { - return a->fetch_sub(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_sub(volatile Atomic<_T> *__a, _T __op) { + return __a->fetch_sub(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub(Atomic *a, T op) { - return a->fetch_sub(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_sub(Atomic<_T> *__a, _T __op) { + return __a->fetch_sub(__op); } - template - inline T *atomic_fetch_sub(volatile Atomic *a, ptrdiff_t op) { - return a->fetch_sub(op); + template + inline _T *atomic_fetch_sub(volatile Atomic<_T *> *__a, ptrdiff_t __op) { + return __a->fetch_sub(__op); } - template - inline T *atomic_fetch_sub(Atomic *a, ptrdiff_t op) { - return a->fetch_sub(op); + template + inline _T *atomic_fetch_sub(Atomic<_T *> *__a, ptrdiff_t __op) { + return __a->fetch_sub(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub_explicit(volatile Atomic *a, T op, MemoryOrder ord) { - return a->fetch_sub(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_sub_explicit(volatile Atomic<_T> *__a, _T __op, + MemoryOrder __ord) { + return __a->fetch_sub(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub_explicit(Atomic *a, T op, MemoryOrder ord) { - return a->fetch_sub(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_sub_explicit(Atomic<_T> *__a, _T __op, MemoryOrder __ord) { + return __a->fetch_sub(__op, __ord); } - template - inline T *atomic_fetch_sub_explicit(volatile Atomic *a, ptrdiff_t op, - MemoryOrder ord) { - return a->fetch_sub(op, ord); + template + inline _T *atomic_fetch_sub_explicit(volatile Atomic<_T *> *__a, + ptrdiff_t __op, + MemoryOrder __ord) { + return __a->fetch_sub(__op, __ord); } - template - inline T *atomic_fetch_sub_explicit(Atomic *a, ptrdiff_t op, - MemoryOrder ord) { - return a->fetch_sub(op, ord); + template + inline _T *atomic_fetch_sub_explicit(Atomic<_T *> *__a, ptrdiff_t __op, + MemoryOrder __ord) { + return __a->fetch_sub(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and(volatile Atomic *a, T op) { - return a->fetch_and(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_and(volatile Atomic<_T> *__a, _T __op) { + return __a->fetch_and(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and(Atomic *a, T op) { - return a->fetch_and(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_and(Atomic<_T> *__a, _T __op) { + return __a->fetch_and(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and_explicit(volatile Atomic *a, T op, MemoryOrder ord) { - return a->fetch_and(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_and_explicit(volatile Atomic<_T> *__a, _T __op, + MemoryOrder __ord) { + return __a->fetch_and(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and_explicit(Atomic *a, T op, MemoryOrder ord) { - return a->fetch_and(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_and_explicit(Atomic<_T> *__a, _T __op, MemoryOrder __ord) { + return __a->fetch_and(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or(volatile Atomic *a, T op) { - return a->fetch_or(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_or(volatile Atomic<_T> *__a, _T __op) { + return __a->fetch_or(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or(Atomic *a, T op) { - return a->fetch_or(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_or(Atomic<_T> *__a, _T __op) { + return __a->fetch_or(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or_explicit(volatile Atomic *a, T op, MemoryOrder ord) { - return a->fetch_or(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_or_explicit(volatile Atomic<_T> *__a, _T __op, + MemoryOrder __ord) { + return __a->fetch_or(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or_explicit(Atomic *a, T op, MemoryOrder ord) { - return a->fetch_or(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_or_explicit(Atomic<_T> *__a, _T __op, MemoryOrder __ord) { + return __a->fetch_or(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor(volatile Atomic *a, T op) { - return a->fetch_xor(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_xor(volatile Atomic<_T> *__a, _T __op) { + return __a->fetch_xor(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor(Atomic *a, T op) { - return a->fetch_xor(op); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_xor(Atomic<_T> *__a, _T __op) { + return __a->fetch_xor(__op); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor_explicit(volatile Atomic *a, T op, MemoryOrder ord) { - return a->fetch_xor(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_xor_explicit(volatile Atomic<_T> *__a, _T __op, + MemoryOrder __ord) { + return __a->fetch_xor(__op, __ord); } - template - inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor_explicit(Atomic *a, T op, MemoryOrder ord) { - return a->fetch_xor(op, ord); + template + inline octa::EnableIf::value && + !octa::IsSame<_T, bool>::value, _T> + atomic_fetch_xor_explicit(Atomic<_T> *__a, _T __op, MemoryOrder __ord) { + return __a->fetch_xor(__op, __ord); } struct AtomicFlag { - __OctaAtomicBase p_a; + __OctaAtomicBase __a; AtomicFlag() = default; - AtomicFlag(bool b): p_a(b) {} + AtomicFlag(bool __b): __a(__b) {} AtomicFlag(const AtomicFlag &) = delete; AtomicFlag &operator=(const AtomicFlag &) = delete; AtomicFlag &operator=(const AtomicFlag &) volatile = delete; - bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) volatile { - return __octa_atomic_exchange(&p_a, true, ord); + bool test_and_set(MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + return __octa_atomic_exchange(&__a, true, __ord); } - bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) { - return __octa_atomic_exchange(&p_a, true, ord); + bool test_and_set(MemoryOrder __ord = MemoryOrder::seq_cst) { + return __octa_atomic_exchange(&__a, true, __ord); } - void clear(MemoryOrder ord = MemoryOrder::seq_cst) volatile { - __octa_atomic_store(&p_a, false, ord); + void clear(MemoryOrder __ord = MemoryOrder::seq_cst) volatile { + __octa_atomic_store(&__a, false, __ord); } - void clear(MemoryOrder ord = MemoryOrder::seq_cst) { - __octa_atomic_store(&p_a, false, ord); + void clear(MemoryOrder __ord = MemoryOrder::seq_cst) { + __octa_atomic_store(&__a, false, __ord); } }; - inline bool atomic_flag_test_and_set(volatile AtomicFlag *a) { - return a->test_and_set(); + inline bool atomic_flag_test_and_set(volatile AtomicFlag *__a) { + return __a->test_and_set(); } - inline bool atomic_flag_test_and_set(AtomicFlag *a) { - return a->test_and_set(); + inline bool atomic_flag_test_and_set(AtomicFlag *__a) { + return __a->test_and_set(); } - inline bool atomic_flag_test_and_set_explicit(volatile AtomicFlag *a, - MemoryOrder ord) { - return a->test_and_set(ord); + inline bool atomic_flag_test_and_set_explicit(volatile AtomicFlag *__a, + MemoryOrder __ord) { + return __a->test_and_set(__ord); } - inline bool atomic_flag_test_and_set_explicit(AtomicFlag *a, - MemoryOrder ord) { - return a->test_and_set(ord); + inline bool atomic_flag_test_and_set_explicit(AtomicFlag *__a, + MemoryOrder __ord) { + return __a->test_and_set(__ord); } - inline void atomic_flag_clear(volatile AtomicFlag *a) { - a->clear(); + inline void atomic_flag_clear(volatile AtomicFlag *__a) { + __a->clear(); } - inline void atomic_flag_clear(AtomicFlag *a) { - a->clear(); + inline void atomic_flag_clear(AtomicFlag *__a) { + __a->clear(); } - inline void atomic_flag_clear_explicit(volatile AtomicFlag *a, - MemoryOrder ord) { - a->clear(ord); + inline void atomic_flag_clear_explicit(volatile AtomicFlag *__a, + MemoryOrder __ord) { + __a->clear(__ord); } - inline void atomic_flag_clear_explicit(AtomicFlag *a, MemoryOrder ord) { - a->clear(ord); + inline void atomic_flag_clear_explicit(AtomicFlag *__a, MemoryOrder __ord) { + __a->clear(__ord); } - inline void atomic_thread_fence(MemoryOrder ord) { - __octa_atomic_thread_fence(ord); + inline void atomic_thread_fence(MemoryOrder __ord) { + __octa_atomic_thread_fence(__ord); } - inline void atomic_signal_fence(MemoryOrder ord) { - __octa_atomic_signal_fence(ord); + inline void atomic_signal_fence(MemoryOrder __ord) { + __octa_atomic_signal_fence(__ord); } typedef Atomic AtomicBool; diff --git a/octa/functional.h b/octa/functional.h index 67ae35d..dcbcfd7 100644 --- a/octa/functional.h +++ b/octa/functional.h @@ -14,12 +14,14 @@ namespace octa { /* basic function objects */ -#define __OCTA_DEFINE_BINARY_OP(name, op, rettype) \ - template struct name { \ - rettype operator()(const T &x, const T &y) const { return x op y; } \ - typedef T FirstArgType; \ - typedef T SecondArgType; \ - typedef rettype ResultType; \ +#define __OCTA_DEFINE_BINARY_OP(_name, _op, _rettype) \ + template struct _name { \ + _rettype operator()(const _T &__x, const _T &__y) const { \ + return __x _op __y; \ + } \ + typedef _T FirstArgType; \ + typedef _T SecondArgType; \ + typedef _rettype ResultType; \ }; __OCTA_DEFINE_BINARY_OP(Less, <, bool) @@ -30,78 +32,78 @@ namespace octa { __OCTA_DEFINE_BINARY_OP(NotEqual, !=, bool) __OCTA_DEFINE_BINARY_OP(LogicalAnd, &&, bool) __OCTA_DEFINE_BINARY_OP(LogicalOr, ||, bool) - __OCTA_DEFINE_BINARY_OP(Modulus, %, T) - __OCTA_DEFINE_BINARY_OP(Multiplies, *, T) - __OCTA_DEFINE_BINARY_OP(Divides, /, T) - __OCTA_DEFINE_BINARY_OP(Plus, +, T) - __OCTA_DEFINE_BINARY_OP(Minus, -, T) - __OCTA_DEFINE_BINARY_OP(BitAnd, &, T) - __OCTA_DEFINE_BINARY_OP(BitOr, |, T) - __OCTA_DEFINE_BINARY_OP(BitXor, ^, T) + __OCTA_DEFINE_BINARY_OP(Modulus, %, _T) + __OCTA_DEFINE_BINARY_OP(Multiplies, *, _T) + __OCTA_DEFINE_BINARY_OP(Divides, /, _T) + __OCTA_DEFINE_BINARY_OP(Plus, +, _T) + __OCTA_DEFINE_BINARY_OP(Minus, -, _T) + __OCTA_DEFINE_BINARY_OP(BitAnd, &, _T) + __OCTA_DEFINE_BINARY_OP(BitOr, |, _T) + __OCTA_DEFINE_BINARY_OP(BitXor, ^, _T) #undef __OCTA_DEFINE_BINARY_OP - template struct LogicalNot { - bool operator()(const T &x) const { return !x; } - typedef T ArgType; + template struct LogicalNot { + bool operator()(const _T &__x) const { return !__x; } + typedef _T ArgType; typedef bool ResultType; }; - template struct Negate { - bool operator()(const T &x) const { return -x; } - typedef T ArgType; - typedef T ResultType; + template struct Negate { + bool operator()(const _T &__x) const { return -__x; } + typedef _T ArgType; + typedef _T ResultType; }; - template struct BinaryNegate { - typedef typename T::FirstArgType FirstArgType; - typedef typename T::SecondArgType SecondArgType; + template struct BinaryNegate { + typedef typename _T::FirstArgType FirstArgType; + typedef typename _T::SecondArgType SecondArgType; typedef bool ResultType; - explicit BinaryNegate(const T &f): p_fn(f) {} + explicit BinaryNegate(const _T &__f): __fn(__f) {} - bool operator()(const FirstArgType &x, - const SecondArgType &y) { - return !p_fn(x, y); + bool operator()(const FirstArgType &__x, + const SecondArgType &__y) { + return !__fn(__x, __y); } private: - T p_fn; + _T __fn; }; - template struct UnaryNegate { - typedef typename T::ArgType ArgType; + template struct UnaryNegate { + typedef typename _T::ArgType ArgType; typedef bool ResultType; - explicit UnaryNegate(const T &f): p_fn(f) {} - bool operator()(const ArgType &x) { - return !p_fn(x); + explicit UnaryNegate(const _T &__f): __fn(__f) {} + bool operator()(const ArgType &__x) { + return !__fn(__x); } private: - T p_fn; + _T __fn; }; - template UnaryNegate not1(const T &fn) { - return UnaryNegate(fn); + template UnaryNegate<_T> not1(const _T &__fn) { + return UnaryNegate<_T>(__fn); } - template BinaryNegate not2(const T &fn) { - return BinaryNegate(fn); + template BinaryNegate<_T> not2(const _T &__fn) { + return BinaryNegate<_T>(__fn); } /* hash */ - template struct Hash; + template struct Hash; - template struct __OctaHashBase { - typedef T ArgType; + template struct __OctaHashBase { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - return (size_t)v; + size_t operator()(_T __v) const { + return size_t(__v); } }; -#define __OCTA_HASH_BASIC(T) template<> struct Hash: __OctaHashBase {}; +#define __OCTA_HASH_BASIC(_T) template<> struct Hash<_T>: __OctaHashBase<_T> {}; __OCTA_HASH_BASIC(bool) __OCTA_HASH_BASIC(char) @@ -119,69 +121,69 @@ namespace octa { #undef __OCTA_HASH_BASIC - static inline size_t __octa_mem_hash(const void *p, size_t l) { - const uchar *d = (const uchar *)p; - size_t h = 5381; - for (size_t i = 0; i < l; ++i) h = ((h << 5) + h) ^ d[i]; - return h; + static inline size_t __octa_mem_hash(const void *__p, size_t __l) { + const uchar *__d = (const uchar *)__p; + size_t __h = 5381; + for (size_t __i = 0; __i < __l; ++__i) __h = ((__h << 5) + __h) ^ __d[__i]; + return __h; } - template + template struct __OctaScalarHash; - template struct __OctaScalarHash { - typedef T ArgType; + template struct __OctaScalarHash<_T, 0> { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - union { T v; size_t h; } u; - u.h = 0; - u.v = v; - return u.h; + size_t operator()(_T __v) const { + union { _T __v; size_t __h; } __u; + __u.__h = 0; + __u.__v = __v; + return __u.__h; } }; - template struct __OctaScalarHash { - typedef T ArgType; + template struct __OctaScalarHash<_T, 1> { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - union { T v; size_t h; } u; - u.v = v; - return u.h; + size_t operator()(_T __v) const { + union { _T __v; size_t __h; } __u; + __u.__v = __v; + return __u.__h; } }; - template struct __OctaScalarHash { - typedef T ArgType; + template struct __OctaScalarHash<_T, 2> { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - union { T v; struct { size_t h1, h2; }; } u; - u.v = v; - return __octa_mem_hash((const void *)&u, sizeof(u)); + size_t operator()(_T __v) const { + union { _T __v; struct { size_t __h1, __h2; }; } __u; + __u.__v = __v; + return __octa_mem_hash((const void *)&__u, sizeof(__u)); } }; - template struct __OctaScalarHash { - typedef T ArgType; + template struct __OctaScalarHash<_T, 3> { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - union { T v; struct { size_t h1, h2, h3; }; } u; - u.v = v; - return __octa_mem_hash((const void *)&u, sizeof(u)); + size_t operator()(_T __v) const { + union { _T __v; struct { size_t __h1, __h2, __h3; }; } __u; + __u.__v = __v; + return __octa_mem_hash((const void *)&__u, sizeof(__u)); } }; - template struct __OctaScalarHash { - typedef T ArgType; + template struct __OctaScalarHash<_T, 4> { + typedef _T ArgType; typedef size_t ResultType; - size_t operator()(T v) const { - union { T v; struct { size_t h1, h2, h3, h4; }; } u; - u.v = v; - return __octa_mem_hash((const void *)&u, sizeof(u)); + size_t operator()(_T __v) const { + union { _T __v; struct { size_t __h1, __h2, __h3, __h4; }; } __u; + __u.__v = __v; + return __octa_mem_hash((const void *)&__u, sizeof(__u)); } }; @@ -189,146 +191,146 @@ namespace octa { template<> struct Hash: __OctaScalarHash {}; template<> struct Hash: __OctaScalarHash { - size_t operator()(float v) const { - if (v == 0) return 0; - return __OctaScalarHash::operator()(v); + size_t operator()(float __v) const { + if (__v == 0) return 0; + return __OctaScalarHash::operator()(__v); } }; template<> struct Hash: __OctaScalarHash { - size_t operator()(double v) const { - if (v == 0) return 0; - return __OctaScalarHash::operator()(v); + size_t operator()(double __v) const { + if (__v == 0) return 0; + return __OctaScalarHash::operator()(__v); } }; template<> struct Hash: __OctaScalarHash { - size_t operator()(ldouble v) const { - if (v == 0) return 0; + size_t operator()(ldouble __v) const { + if (__v == 0) return 0; #ifdef __i386__ - union { ldouble v; struct { size_t h1, h2, h3, h4; }; } u; - u.h1 = u.h2 = u.h3 = u.h4 = 0; - u.v = v; - return (u.h1 ^ u.h2 ^ u.h3 ^ u.h4); + union { ldouble __v; struct { size_t __h1, __h2, __h3, __h4; }; } __u; + __u.__h1 = __u.__h2 = __u.__h3 = __u.__h4 = 0; + __u.__v = __v; + return (__u.__h1 ^ __u.__h2 ^ __u.__h3 ^ __u.__h4); #else #ifdef __x86_64__ - union { ldouble v; struct { size_t h1, h2; }; } u; - u.h1 = u.h2 = 0; - u.v = v; - return (u.h1 ^ u.h2); + union { ldouble __v; struct { size_t __h1, __h2; }; } __u; + __u.__h1 = __u.__h2 = 0; + __u.__v = __v; + return (__u.__h1 ^ __u.__h2); #else - return __OctaScalarHash::operator()(v); + return __OctaScalarHash::operator()(__v); #endif #endif } }; - template struct Hash { - typedef T *ArgType; + template struct Hash<_T *> { + typedef _T *ArgType; typedef size_t ResultType; - size_t operator()(T *v) const { - union { T *v; size_t h; } u; - u.v = v; - return __octa_mem_hash((const void *)&u, sizeof(u)); + size_t operator()(_T *__v) const { + union { _T *__v; size_t __h; } __u; + __u.__v = __v; + return __octa_mem_hash((const void *)&__u, sizeof(__u)); } }; /* reference wrapper */ - template + template struct ReferenceWrapper { - typedef T type; + typedef _T type; - ReferenceWrapper(T &v): p_ptr(address_of(v)) {} + ReferenceWrapper(_T &__v): __ptr(address_of(__v)) {} ReferenceWrapper(const ReferenceWrapper &) = default; - ReferenceWrapper(T &&) = delete; + ReferenceWrapper(_T &&) = delete; ReferenceWrapper &operator=(const ReferenceWrapper &) = default; - operator T &() const { return *p_ptr; } - T &get() const { return *p_ptr; } + operator _T &() const { return *__ptr; } + _T &get() const { return *__ptr; } private: - T *p_ptr; + _T *__ptr; }; - template - ReferenceWrapper ref(T &v) { - return ReferenceWrapper(v); + template + ReferenceWrapper<_T> ref(_T &__v) { + return ReferenceWrapper<_T>(__v); } - template - ReferenceWrapper ref(ReferenceWrapper v) { - return ReferenceWrapper(v); + template + ReferenceWrapper<_T> ref(ReferenceWrapper<_T> __v) { + return ReferenceWrapper<_T>(__v); } - template void ref(const T &&) = delete; + template void ref(const _T &&) = delete; - template - ReferenceWrapper cref(const T &v) { - return ReferenceWrapper(v); + template + ReferenceWrapper cref(const _T &__v) { + return ReferenceWrapper<_T>(__v); } - template - ReferenceWrapper cref(ReferenceWrapper v) { - return ReferenceWrapper(v); + template + ReferenceWrapper cref(ReferenceWrapper<_T> __v) { + return ReferenceWrapper<_T>(__v); } - template void cref(const T &&) = delete; + template void cref(const _T &&) = delete; /* mem_fn */ template struct __OctaMemTypes; - template - struct __OctaMemTypes { - typedef R ResultType; - typedef T ArgType; + template + struct __OctaMemTypes<_T, _R(_A...)> { + typedef _R ResultType; + typedef _T ArgType; }; - template - struct __OctaMemTypes { - typedef R ResultType; - typedef T FirstArgType; - typedef A SecondArgType; + template + struct __OctaMemTypes<_T, _R(_A)> { + typedef _R ResultType; + typedef _T FirstArgType; + typedef _A SecondArgType; }; - template - struct __OctaMemTypes { - typedef R ResultType; - typedef const T ArgType; + template + struct __OctaMemTypes<_T, _R(_A...) const> { + typedef _R ResultType; + typedef const _T ArgType; }; - template - struct __OctaMemTypes { - typedef R ResultType; - typedef const T FirstArgType; - typedef A SecondArgType; + template + struct __OctaMemTypes<_T, _R(_A) const> { + typedef _R ResultType; + typedef const _T FirstArgType; + typedef _A SecondArgType; }; - template - class __OctaMemFn: __OctaMemTypes { - R T::*p_ptr; + template + class __OctaMemFn: __OctaMemTypes<_T, _R> { + _R _T::*__ptr; public: - __OctaMemFn(R T::*ptr): p_ptr(ptr) {} - template - auto operator()(T &obj, A &&...args) -> - decltype(((obj).*(p_ptr))(forward(args)...)) { - return ((obj).*(p_ptr))(forward(args)...); + __OctaMemFn(_R _T::*__ptr): __ptr(__ptr) {} + template + auto operator()(_T &__obj, _A &&...__args) -> + decltype(((__obj).*(__ptr))(forward<_A>(__args)...)) { + return ((__obj).*(__ptr))(forward<_A>(__args)...); } - template - auto operator()(const T &obj, A &&...args) -> - decltype(((obj).*(p_ptr))(forward(args)...)) const { - return ((obj).*(p_ptr))(forward(args)...); + template + auto operator()(const _T &__obj, _A &&...__args) -> + decltype(((__obj).*(__ptr))(forward<_A>(__args)...)) const { + return ((__obj).*(__ptr))(forward<_A>(__args)...); } - template - auto operator()(T *obj, A &&...args) -> - decltype(((obj)->*(p_ptr))(forward(args)...)) { - return ((obj)->*(p_ptr))(forward(args)...); + template + auto operator()(_T *__obj, _A &&...__args) -> + decltype(((__obj)->*(__ptr))(forward<_A>(__args)...)) { + return ((__obj)->*(__ptr))(forward<_A>(__args)...); } - template - auto operator()(const T *obj, A &&...args) -> - decltype(((obj)->*(p_ptr))(forward(args)...)) const { - return ((obj)->*(p_ptr))(forward(args)...); + template + auto operator()(const _T *__obj, _A &&...__args) -> + decltype(((__obj)->*(__ptr))(forward<_A>(__args)...)) const { + return ((__obj)->*(__ptr))(forward<_A>(__args)...); } }; - template - __OctaMemFn mem_fn(R T:: *ptr) { - return __OctaMemFn(ptr); + template + __OctaMemFn<_R, _T> mem_fn(_R _T:: *__ptr) { + return __OctaMemFn<_R, _T>(__ptr); } /* function impl @@ -338,296 +340,303 @@ namespace octa { template struct Function; struct __OctaFunctorData { - void *p1, *p2; + void *__p1, *__p2; }; - template + template struct __OctaFunctorInPlace { - static constexpr bool value = sizeof(T) <= sizeof(__OctaFunctorData) - && (alignof(__OctaFunctorData) % alignof(T)) == 0 - && octa::IsMoveConstructible::value; + static constexpr bool value = sizeof(_T) <= sizeof(__OctaFunctorData) + && (alignof(__OctaFunctorData) % alignof(_T)) == 0 + && octa::IsMoveConstructible<_T>::value; }; - template + template struct __OctaFunctorDataManager { - template - static R call(const __OctaFunctorData &s, A ...args) { - return ((T &)s)(forward(args)...); + template + static _R __call(const __OctaFunctorData &__s, _A ...__args) { + return ((_T &)__s)(octa::forward<_A>(__args)...); } - static void store_f(__OctaFunctorData &s, T v) { - new (&get_ref(s)) T(forward(v)); + static void __store_f(__OctaFunctorData &__s, _T __v) { + new (&__get_ref(__s)) _T(octa::forward<_T>(__v)); } - static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) { - new (&get_ref(lhs)) T(move(get_ref(rhs))); + static void __move_f(__OctaFunctorData &__lhs, __OctaFunctorData &&__rhs) { + new (&__get_ref(__lhs)) _T(octa::move(__get_ref(__rhs))); } - static void destroy_f(__OctaFunctorData &s) { - get_ref(s).~T(); + static void __destroy_f(__OctaFunctorData &__s) { + __get_ref(__s).~_T(); } - static T &get_ref(const __OctaFunctorData &s) { - return (T &)s; + static _T &__get_ref(const __OctaFunctorData &__s) { + return (_T &)__s; } }; - template - struct __OctaFunctorDataManager::value>> { - template - static R call(const __OctaFunctorData &s, A ...args) { - return (*(T *&)s)(forward(args)...); + template + struct __OctaFunctorDataManager<_T, EnableIf::value>> { + template + static _R __call(const __OctaFunctorData &__s, _A ...__args) { + return (*(_T *&)__s)(octa::forward<_A>(__args)...); } - static void store_f(__OctaFunctorData &s, T v) { - new (&get_ptr_ref(s)) T *(new T(forward(v))); + static void __store_f(__OctaFunctorData &__s, _T __v) { + new (&__get_ptr_ref(__s)) _T *(new _T(octa::forward<_T>(__v))); } - static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) { - new (&get_ptr_ref(lhs)) T *(get_ptr_ref(rhs)); - get_ptr_ref(rhs) = nullptr; + static void __move_f(__OctaFunctorData &__lhs, __OctaFunctorData &&__rhs) { + new (&__get_ptr_ref(__lhs)) _T *(__get_ptr_ref(__rhs)); + __get_ptr_ref(__rhs) = nullptr; } - static void destroy_f(__OctaFunctorData &s) { - T *&ptr = get_ptr_ref(s); - if (!ptr) return; - delete ptr; - ptr = nullptr; + static void __destroy_f(__OctaFunctorData &__s) { + _T *&__ptr = __get_ptr_ref(__s); + if (!__ptr) return; + delete __ptr; + __ptr = nullptr; } - static T &get_ref(const __OctaFunctorData &s) { - return *get_ptr_ref(s); + static _T &__get_ref(const __OctaFunctorData &__s) { + return *__get_ptr_ref(__s); } - static T *&get_ptr_ref(__OctaFunctorData &s) { - return (T *&)s; + static _T *&__get_ptr_ref(__OctaFunctorData &__s) { + return (_T *&)__s; } - static T *&get_ptr_ref(const __OctaFunctorData &s) { - return (T *&)s; + static _T *&__get_ptr_ref(const __OctaFunctorData &__s) { + return (_T *&)__s; } }; struct __OctaFunctionManager; struct __OctaFmStorage { - __OctaFunctorData data; - const __OctaFunctionManager *manager; + __OctaFunctorData __data; + const __OctaFunctionManager *__manager; }; - template + template static const __OctaFunctionManager &__octa_get_default_fm(); struct __OctaFunctionManager { - template - inline static const __OctaFunctionManager create_default_manager() { + template + inline static const __OctaFunctionManager __create_default_manager() { return __OctaFunctionManager { - &t_call_move_and_destroy, - &t_call_copy, - &t_call_destroy + &__call_move_and_destroy<_T>, + &__call_copy<_T>, + &__call_destroy<_T> }; } - void (* const call_move_and_destroy)(__OctaFmStorage &lhs, - __OctaFmStorage &&rhs); - void (* const call_copy)(__OctaFmStorage &lhs, - const __OctaFmStorage &rhs); - void (* const call_destroy)(__OctaFmStorage &s); + void (* const __call_move_and_destroyf)(__OctaFmStorage &__lhs, + __OctaFmStorage &&__rhs); + void (* const __call_copyf)(__OctaFmStorage &__lhs, + const __OctaFmStorage &__rhs); + void (* const __call_destroyf)(__OctaFmStorage &__s); - template - static void t_call_move_and_destroy(__OctaFmStorage &lhs, - __OctaFmStorage &&rhs) { - typedef __OctaFunctorDataManager spec; - spec::move_f(lhs.data, move(rhs.data)); - spec::destroy_f(rhs.data); - lhs.manager = &__octa_get_default_fm(); + template + static void __call_move_and_destroy(__OctaFmStorage &__lhs, + __OctaFmStorage &&__rhs) { + typedef __OctaFunctorDataManager<_T> _spec; + _spec::__move_f(__lhs.__data, octa::move(__rhs.__data)); + _spec::__destroy_f(__rhs.__data); + __lhs.__manager = &__octa_get_default_fm<_T>(); } - template - static void t_call_copy(__OctaFmStorage &lhs, - const __OctaFmStorage &rhs) { - typedef __OctaFunctorDataManager spec; - lhs.manager = &__octa_get_default_fm(); - spec::store_f(lhs.data, spec::get_ref(rhs.data)); + template + static void __call_copy(__OctaFmStorage &__lhs, + const __OctaFmStorage &__rhs) { + typedef __OctaFunctorDataManager<_T> _spec; + __lhs.__manager = &__octa_get_default_fm<_T>(); + _spec::__store_f(__lhs.__data, _spec::__get_ref(__rhs.__data)); } - template - static void t_call_destroy(__OctaFmStorage &s) { - typedef __OctaFunctorDataManager spec; - spec::destroy_f(s.data); + template + static void __call_destroy(__OctaFmStorage &__s) { + typedef __OctaFunctorDataManager<_T> _spec; + _spec::__destroy_f(__s.__data); } }; - template + template inline static const __OctaFunctionManager &__octa_get_default_fm() { - static const __OctaFunctionManager def_manager - = __OctaFunctionManager::create_default_manager(); - return def_manager; + static const __OctaFunctionManager __def_manager + = __OctaFunctionManager::__create_default_manager<_T>(); + return __def_manager; } - template + template struct __OctaFunction { - typedef R ResultType; + typedef _R ResultType; }; - template - struct __OctaFunction { - typedef R ResultType; - typedef T ArgType; + template + struct __OctaFunction<_R, _T> { + typedef _R ResultType; + typedef _T ArgType; }; - template - struct __OctaFunction { - typedef R ResultType; - typedef T FirstArgType; - typedef U SecondArgType; + template + struct __OctaFunction<_R, _T, _U> { + typedef _R ResultType; + typedef _T FirstArgType; + typedef _U SecondArgType; }; template - struct IsValidFunctor { + struct __OctaIsValidFunctor { static constexpr bool value = false; }; - template - struct IsValidFunctor, R(A...)> { + template + struct __OctaIsValidFunctor, _R(_A...)> { static constexpr bool value = false; }; struct __OctaEmpty { }; - template - T func_to_functor(T &&f) { - return forward(f); + template + _T __octa_func_to_functor(_T &&__f) { + return octa::forward<_T>(__f); } - template - auto func_to_functor(RR (T::*f)(AA...)) -> decltype(mem_fn(f)) { - return mem_fn(f); + template + auto __octa_func_to_functor(_RR (_T::*__f)(_AA...)) + -> decltype(mem_fn(__f)) { + return mem_fn(__f); } - template - auto func_to_functor(RR (T::*f)(AA...) const) -> decltype(mem_fn(f)) { - return mem_fn(f); + template + auto __octa_func_to_functor(_RR (_T::*__f)(_AA...) const) + -> decltype(mem_fn(__f)) { + return mem_fn(__f); } - template - struct IsValidFunctor { - template - static decltype(func_to_functor(declval())(declval()...)) __octa_test(U *); + template + struct __OctaIsValidFunctor<_T, _R(_A...)> { + template + static decltype(__octa_func_to_functor(octa::declval<_U>()) + (octa::declval<_A>()...)) __test(_U *); template - static __OctaEmpty __octa_test(...); + static __OctaEmpty __test(...); - static constexpr bool value = IsConvertible< - decltype(__octa_test(nullptr)), R + static constexpr bool value = octa::IsConvertible< + decltype(__test<_T>(nullptr)), _R >::value; }; - template - struct Function: __OctaFunction { - Function( ) { initialize_empty(); } - Function(nullptr_t) { initialize_empty(); } + template + struct Function<_R(_A...)>: __OctaFunction<_R, _A...> { + Function( ) { __init_empty(); } + Function(nullptr_t) { __init_empty(); } - Function(Function &&f) { - initialize_empty(); - swap(f); + Function(Function &&__f) { + __init_empty(); + swap(__f); } - Function(const Function &f): p_call(f.p_call) { - f.p_stor.manager->call_copy(p_stor, f.p_stor); + Function(const Function &__f): __call(__f.__call) { + __f.__stor.__manager->__call_copyf(__stor, __f.__stor); } - template - Function(T f, EnableIf::value, __OctaEmpty> + template + Function(_T __f, EnableIf<__OctaIsValidFunctor<_T, _R(_A...)>::value, __OctaEmpty> = __OctaEmpty()) { - if (func_is_null(f)) { - initialize_empty(); + if (__func_is_null(__f)) { + __init_empty(); return; } - initialize(func_to_functor(forward(f))); + __initialize(__octa_func_to_functor(octa::forward<_T>(__f))); } ~Function() { - p_stor.manager->call_destroy(p_stor); + __stor.__manager->__call_destroyf(__stor); } - Function &operator=(Function &&f) { - p_stor.manager->call_destroy(p_stor); - swap(f); + Function &operator=(Function &&__f) { + __stor.__manager->__call_destroyf(__stor); + swap(__f); return *this; } - Function &operator=(const Function &f) { - p_stor.manager->call_destroy(p_stor); - f.p_stor.manager->call_copy(p_stor, f.p_stor); + Function &operator=(const Function &__f) { + __stor.__manager->__call_destroyf(__stor); + __f.__stor.__manager->__call_copyf(__stor, __f.__stor); return *this; }; - R operator()(A ...args) const { - return p_call(p_stor.data, forward(args)...); + _R operator()(_A ...__args) const { + return __call(__stor.__data, octa::forward<_A>(__args)...); } - template void assign(F &&f) { - Function(forward(f)).swap(*this); + template void assign(_F &&__f) { + Function(octa::forward<_F>(__f)).swap(*this); } - void swap(Function &f) { - __OctaFmStorage tmp; - f.p_stor.manager->call_move_and_destroy(tmp, move(f.p_stor)); - p_stor.manager->call_move_and_destroy(f.p_stor, move(p_stor)); - tmp.manager->call_move_and_destroy(p_stor, move(tmp)); - octa::swap(p_call, f.p_call); + void swap(Function &__f) { + __OctaFmStorage __tmp; + __f.__stor.__manager->__call_move_and_destroyf(__tmp, + octa::move(__f.__stor)); + __stor.__manager->__call_move_and_destroyf(__f.__stor, + octa::move(__stor)); + __tmp.__manager->__call_move_and_destroyf(__stor, + octa::move(__tmp)); + octa::swap(__call, __f.__call); } - operator bool() const { return p_call != nullptr; } + operator bool() const { return __call != nullptr; } private: - __OctaFmStorage p_stor; - R (*p_call)(const __OctaFunctorData &, A...); + __OctaFmStorage __stor; + _R (*__call)(const __OctaFunctorData &, _A...); - template - void initialize(T f) { - p_call = &__OctaFunctorDataManager::template call; - p_stor.manager = &__octa_get_default_fm(); - __OctaFunctorDataManager::store_f(p_stor.data, forward(f)); + template + void __initialize(_T __f) { + __call = &__OctaFunctorDataManager<_T>::template __call<_R, _A...>; + __stor.__manager = &__octa_get_default_fm<_T>(); + __OctaFunctorDataManager<_T>::__store_f(__stor.__data, + octa::forward<_T>(__f)); } - void initialize_empty() { - typedef R(*emptyf)(A...); - p_call = nullptr; - p_stor.manager = &__octa_get_default_fm(); - __OctaFunctorDataManager::store_f(p_stor.data, nullptr); + void __init_empty() { + typedef _R(*__emptyf)(_A...); + __call = nullptr; + __stor.__manager = &__octa_get_default_fm<__emptyf>(); + __OctaFunctorDataManager<__emptyf>::__store_f(__stor.__data, nullptr); } - template - static bool func_is_null(const T &) { return false; } + template + static bool __func_is_null(const _T &) { return false; } - static bool func_is_null(R (* const &fptr)(A...)) { - return fptr == nullptr; + static bool __func_is_null(_R (* const &__fptr)(_A...)) { + return __fptr == nullptr; } - template - static bool func_is_null(RR (T::* const &fptr)(AA...)) { - return fptr == nullptr; + template + static bool __func_is_null(_RR (_T::* const &__fptr)(_AA...)) { + return __fptr == nullptr; } - template - static bool func_is_null(RR (T::* const &fptr)(AA...) const) { - return fptr == nullptr; + template + static bool __func_is_null(_RR (_T::* const &__fptr)(_AA...) const) { + return __fptr == nullptr; } }; - template - bool operator==(nullptr_t, const Function &rhs) { return !rhs; } + template + bool operator==(nullptr_t, const Function<_T> &__rhs) { return !__rhs; } - template - bool operator==(const Function &lhs, nullptr_t) { return !lhs; } + template + bool operator==(const Function<_T> &__lhs, nullptr_t) { return !__lhs; } - template - bool operator!=(nullptr_t, const Function &rhs) { return rhs; } + template + bool operator!=(nullptr_t, const Function<_T> &__rhs) { return __rhs; } - template - bool operator!=(const Function &lhs, nullptr_t) { return lhs; } + template + bool operator!=(const Function<_T> &__lhs, nullptr_t) { return __lhs; } } #endif \ No newline at end of file diff --git a/octa/initializer_list.h b/octa/initializer_list.h index b3a919f..08af051 100644 --- a/octa/initializer_list.h +++ b/octa/initializer_list.h @@ -13,19 +13,19 @@ #ifndef OCTA_ALLOW_CXXSTD /* must be in std namespace otherwise the compiler won't know about it */ namespace std { - template + template class initializer_list { - const T *p_buf; - size_t p_len; + const _T *__buf; + size_t __len; - initializer_list(const T *v, size_t n): p_buf(v), p_len(n) {} + initializer_list(const _T *__v, size_t __n): __buf(__v), __len(__n) {} public: - initializer_list(): p_buf(nullptr), p_len(0) {} + initializer_list(): __buf(nullptr), __len(0) {} - size_t size() const { return p_len; } + size_t size() const { return __len; } - const T *begin() const { return p_buf; } - const T *end() const { return p_buf + p_len; } + const _T *begin() const { return __buf; } + const _T *end() const { return __buf + __len; } }; } #else @@ -33,13 +33,11 @@ namespace std { #endif namespace octa { - using std::initializer_list; + template using InitializerList = std::initializer_list<_T>; - template using InitializerList = std::initializer_list; - - template - octa::PointerRange each(initializer_list init) { - return octa::PointerRange(init.begin(), init.end()); + template + octa::PointerRange each(std::initializer_list<_T> __init) { + return octa::PointerRange(__init.begin(), __init.end()); } } diff --git a/octa/memory.h b/octa/memory.h index 1f9c818..dfeb99f 100644 --- a/octa/memory.h +++ b/octa/memory.h @@ -15,312 +15,319 @@ namespace octa { /* address of */ - template constexpr T *address_of(T &v) { - return reinterpret_cast(&const_cast - (reinterpret_cast(v))); + template constexpr _T *address_of(_T &__v) { + return reinterpret_cast<_T *>(&const_cast + (reinterpret_cast(__v))); } /* pointer traits */ - template + template struct __OctaHasElementType { - template - static int __octa_test(...); - template - static char __octa_test(typename U::ElementType * = 0); + template + static int __test(...); + template + static char __test(typename _U::ElementType * = 0); - static constexpr bool value = (sizeof(__octa_test(0)) == 1); + static constexpr bool value = (sizeof(__test<_T>(0)) == 1); }; - template::value> + template::value> struct __OctaPtrTraitsElementType; - template struct __OctaPtrTraitsElementType { - typedef typename T::ElementType Type; + template struct __OctaPtrTraitsElementType<_T, true> { + typedef typename _T::ElementType Type; }; - template class T, typename U, typename ...A> - struct __OctaPtrTraitsElementType, true> { - typedef typename T::ElementType Type; + template class _T, typename _U, typename ..._A> + struct __OctaPtrTraitsElementType<_T<_U, _A...>, true> { + typedef typename _T<_U, _A...>::ElementType Type; }; - template class T, typename U, typename ...A> - struct __OctaPtrTraitsElementType, false> { - typedef U Type; + template class _T, typename _U, typename ..._A> + struct __OctaPtrTraitsElementType<_T<_U, _A...>, false> { + typedef _U Type; }; - template + template struct __OctaHasDiffType { - template - static int __octa_test(...); - template - static char __octa_test(typename U::DiffType * = 0); + template + static int __test(...); + template + static char __test(typename _U::DiffType * = 0); - static constexpr bool value = (sizeof(__octa_test(0)) == 1); + static constexpr bool value = (sizeof(__test<_T>(0)) == 1); }; - template::value> + template::value> struct __OctaPtrTraitsDiffType { typedef ptrdiff_t Type; }; - template struct __OctaPtrTraitsDiffType { - typedef typename T::DiffType Type; + template struct __OctaPtrTraitsDiffType<_T, true> { + typedef typename _T::DiffType Type; }; - template + template struct __OctaHasRebind { - template - static int __octa_test(...); - template - static char __octa_test(typename V::template rebind * = 0); + template + static int __test(...); + template + static char __test(typename _V::template rebind<_U> * = 0); - static constexpr bool value = (sizeof(__octa_test(0)) == 1); + static constexpr bool value = (sizeof(__test<_T>(0)) == 1); }; - template::value> + template::value> struct __OctaPtrTraitsRebindType { - typedef typename T::template rebind Type; + typedef typename _T::template rebind<_U> Type; }; - template class T, typename U, - typename ...A, typename V + template class _T, typename _U, + typename ..._A, typename _V > - struct __OctaPtrTraitsRebindType, V, true> { - typedef typename T::template rebind Type; + struct __OctaPtrTraitsRebindType<_T<_U, _A...>, _V, true> { + typedef typename _T<_U, _A...>::template rebind<_V> Type; }; - template class T, typename U, - typename ...A, typename V + template class _T, typename _U, + typename ..._A, typename _V > - struct __OctaPtrTraitsRebindType, V, false> { - typedef T Type; + struct __OctaPtrTraitsRebindType<_T<_U, _A...>, _V, false> { + typedef _T<_V, _A...> Type; }; - template + template struct __OctaPtrTraitsPointer { - typedef T Type; + typedef _T Type; }; - template - struct __OctaPtrTraitsPointer { - typedef T *Type; + template + struct __OctaPtrTraitsPointer<_T *> { + typedef _T *Type; }; - template - using PtrType = typename __OctaPtrTraitsPointer::Type; + template + using PtrType = typename __OctaPtrTraitsPointer<_T>::Type; - template + template struct __OctaPtrTraitsElement { - typedef typename __OctaPtrTraitsElementType::Type Type; + typedef typename __OctaPtrTraitsElementType<_T>::Type Type; }; - template - struct __OctaPtrTraitsElement { - typedef T Type; + template + struct __OctaPtrTraitsElement<_T *> { + typedef _T Type; }; - template - using PointerElement = typename __OctaPtrTraitsElement::Type; + template + using PointerElement = typename __OctaPtrTraitsElement<_T>::Type; - template + template struct __OctaPtrTraitsDifference { - typedef typename __OctaPtrTraitsDiffType::Type Type; + typedef typename __OctaPtrTraitsDiffType<_T>::Type Type; }; - template - struct __OctaPtrTraitsDifference { + template + struct __OctaPtrTraitsDifference<_T *> { typedef ptrdiff_t DiffType; }; - template - using PointerDifference = typename __OctaPtrTraitsDifference::Type; + template + using PointerDifference = typename __OctaPtrTraitsDifference<_T>::Type; - template + template struct __OctaPtrTraitsRebind { - using type = typename __OctaPtrTraitsRebindType::Type; + using type = typename __OctaPtrTraitsRebindType<_T, _U>::Type; }; - template - struct __OctaPtrTraitsRebind { - using type = U *; + template + struct __OctaPtrTraitsRebind<_T *, _U> { + using type = _U *; }; - template - using PointerRebind = typename __OctaPtrTraitsRebind::Type; + template + using PointerRebind = typename __OctaPtrTraitsRebind<_T, _U>::Type; struct __OctaPtrTraitsNat {}; - template + template struct __OctaPtrTraitsPointerTo { - static T pointer_to(Conditional>::value, - __OctaPtrTraitsNat, PointerElement - > &r) { - return T::pointer_to(r); + static _T pointer_to(octa::Conditional< + octa::IsVoid>::value, + __OctaPtrTraitsNat, PointerElement<_T> + > &__r) { + return _T::pointer_to(__r); } }; - template - struct __OctaPtrTraitsPointerTo { - static T pointer_to(Conditional::value, __OctaPtrTraitsNat, T - > &r) { - return octa::address_of(r); + template + struct __OctaPtrTraitsPointerTo<_T *> { + static _T pointer_to(octa::Conditional< + octa::IsVoid<_T>::value, __OctaPtrTraitsNat, _T + > &__r) { + return octa::address_of(__r); } }; - template - static T pointer_to(Conditional>::value, - __OctaPtrTraitsNat, PointerElement - > &r) { - return __OctaPtrTraitsPointerTo::pointer_to(r); + template + static _T pointer_to(octa::Conditional< + octa::IsVoid>::value, + __OctaPtrTraitsNat, PointerElement<_T> + > &__r) { + return __OctaPtrTraitsPointerTo<_T>::pointer_to(__r); } /* default deleter */ - template + template struct DefaultDelete { constexpr DefaultDelete() = default; - template DefaultDelete(const DefaultDelete &) {}; + template DefaultDelete(const DefaultDelete<_U> &) {}; - void operator()(T *p) const { - delete p; + void operator()(_T *__p) const { + delete __p; } }; - template - struct DefaultDelete { + template + struct DefaultDelete<_T[]> { constexpr DefaultDelete() = default; - template DefaultDelete(const DefaultDelete &) {}; + template DefaultDelete(const DefaultDelete<_U[]> &) {}; - void operator()(T *p) const { - delete[] p; + void operator()(_T *__p) const { + delete[] __p; } - template void operator()(U *) const = delete; + template void operator()(_U *) const = delete; }; /* box */ - template::value> + template::value> struct __OctaBoxPair; - template - struct __OctaBoxPair { /* non-empty deleter */ - T *i_ptr; + template + struct __OctaBoxPair<_T, _U, false> { /* non-empty deleter */ + _T *__ptr; private: - U p_del; + _U __del; public: - template - __OctaBoxPair(T *ptr, D &&dltr): i_ptr(ptr), p_del(forward(dltr)) {} + template + __OctaBoxPair(_T *__ptr, _D &&__dltr): __ptr(__ptr), + __del(octa::forward<_D>(__dltr)) {} - U &get_deleter() { return p_del; } - const U &get_deleter() const { return p_del; } + _U &get_deleter() { return __del; } + const _U &get_deleter() const { return __del; } - void swap(__OctaBoxPair &v) { - octa::swap(i_ptr, v.i_ptr); - octa::swap(p_del, v.p_del); + void swap(__OctaBoxPair &__v) { + octa::swap(__ptr, __v.__ptr); + octa::swap(__del, __v.__del); } }; - template - struct __OctaBoxPair: U { /* empty deleter */ - T *i_ptr; + template + struct __OctaBoxPair<_T, _U, true>: _U { /* empty deleter */ + _T *__ptr; - template - __OctaBoxPair(T *ptr, D &&dltr): U(forward(dltr)), i_ptr(ptr) {} + template + __OctaBoxPair(_T *__ptr, _D &&__dltr): + _U(octa::forward<_D>(__dltr)), __ptr(__ptr) {} - U &get_deleter() { return *this; } - const U &get_deleter() const { return *this; } + _U &get_deleter() { return *this; } + const _U &get_deleter() const { return *this; } - void swap(__OctaBoxPair &v) { - octa::swap(i_ptr, v.i_ptr); + void swap(__OctaBoxPair &__v) { + octa::swap(__ptr, __v.__ptr); } }; - template + template static int __octa_ptr_test(...); - template - static char __octa_ptr_test(typename T::PtrType * = 0); + template + static char __octa_ptr_test(typename _T::PtrType * = 0); - template struct __OctaHasPtr: IntegralConstant(0)) == 1) + template struct __OctaHasPtr: octa::IntegralConstant(0)) == 1) > {}; - template::value> + template::value> struct __OctaPtrTypeBase { - typedef typename D::PtrType Type; + typedef typename _D::PtrType Type; }; - template struct __OctaPtrTypeBase { - typedef T *Type; + template struct __OctaPtrTypeBase<_T, _D, false> { + typedef _T *Type; }; - template struct __OctaPtrType { - typedef typename __OctaPtrTypeBase>::Type Type; + template struct __OctaPtrType { + typedef typename __OctaPtrTypeBase<_T, octa::RemoveReference<_D>>::Type Type; }; - template> + template> struct Box { - typedef T ElementType; - typedef D DeleterType; - typedef typename __OctaPtrType::Type PtrType; + typedef _T ElementType; + typedef _D DeleterType; + typedef typename __OctaPtrType<_T, _D>::Type PtrType; private: - struct __OctaNat { int x; }; + struct __OctaNat { int __x; }; - typedef RemoveReference &D_ref; - typedef const RemoveReference &D_cref; + typedef RemoveReference<_D> &_D_ref; + typedef const RemoveReference<_D> &_D_cref; public: - constexpr Box(): p_stor(nullptr, D()) { - static_assert(!IsPointer::value, + constexpr Box(): __stor(nullptr, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - constexpr Box(nullptr_t): p_stor(nullptr, D()) { - static_assert(!IsPointer::value, + constexpr Box(nullptr_t): __stor(nullptr, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - explicit Box(PtrType p): p_stor(p, D()) { - static_assert(!IsPointer::value, + explicit Box(PtrType __p): __stor(__p, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - Box(PtrType p, Conditional::value, - D, AddLvalueReference - > d): p_stor(p, d) {} + Box(PtrType __p, octa::Conditional::value, + _D, octa::AddLvalueReference + > __d): __stor(__p, __d) {} - Box(PtrType p, RemoveReference &&d): p_stor(p, move(d)) { - static_assert(!IsReference::value, + Box(PtrType __p, octa::RemoveReference<_D> &&__d): + __stor(__p, octa::move(__d)) { + static_assert(!octa::IsReference<_D>::value, "rvalue deleter cannot be a ref"); } - Box(Box &&u): p_stor(u.release(), forward(u.get_deleter())) {} + Box(Box &&__u): __stor(__u.release(), + octa::forward<_D>(__u.get_deleter())) {} - template - Box(Box &&u, EnableIf::value - && IsConvertible::PtrType, PtrType>::value - && IsConvertible::value - && (!IsReference::value || IsSame::value) - > = __OctaNat()): p_stor(u.release(), forward
(u.get_deleter())) {} + template + Box(Box<_TT, _DD> &&__u, octa::EnableIf::value + && octa::IsConvertible::PtrType, PtrType>::value + && octa::IsConvertible<_DD, _D>::value + && (!octa::IsReference<_D>::value || octa::IsSame<_D, _DD>::value) + > = __OctaNat()): __stor(__u.release(), octa::forward<_DD>(__u.get_deleter())) {} - Box &operator=(Box &&u) { - reset(u.release()); - p_stor.get_deleter() = forward(u.get_deleter()); + Box &operator=(Box &&__u) { + reset(__u.release()); + __stor.get_deleter() = octa::forward<_D>(__u.get_deleter()); return *this; } - template - EnableIf::value - && IsConvertible::PtrType, PtrType>::value - && IsAssignable::value, + template + EnableIf::value + && octa::IsConvertible::PtrType, PtrType>::value + && octa::IsAssignable<_D &, _DD &&>::value, Box & - > operator=(Box &&u) { - reset(u.release()); - p_stor.get_deleter() = forward
(u.get_deleter()); + > operator=(Box<_TT, _DD> &&__u) { + reset(__u.release()); + __stor.get_deleter() = octa::forward<_DD>(__u.get_deleter()); return *this; } @@ -331,128 +338,133 @@ namespace octa { ~Box() { reset(); } - AddLvalueReference operator*() const { return *p_stor.i_ptr; } - PtrType operator->() const { return p_stor.i_ptr; } + octa::AddLvalueReference<_T> operator*() const { return *__stor.__ptr; } + PtrType operator->() const { return __stor.__ptr; } explicit operator bool() const { - return p_stor.i_ptr != nullptr; + return __stor.__ptr != nullptr; } - PtrType get() const { return p_stor.i_ptr; } + PtrType get() const { return __stor.__ptr; } - D_ref get_deleter() { return p_stor.get_deleter(); } - D_cref get_deleter() const { return p_stor.get_deleter(); } + _D_ref get_deleter() { return __stor.get_deleter(); } + _D_cref get_deleter() const { return __stor.get_deleter(); } PtrType release() { - PtrType p = p_stor.i_ptr; - p_stor.i_ptr = nullptr; - return p; + PtrType __p = __stor.__ptr; + __stor.__ptr = nullptr; + return __p; } - void reset(PtrType p = nullptr) { - PtrType tmp = p_stor.i_ptr; - p_stor.i_ptr = p; - if (tmp) p_stor.get_deleter()(tmp); + void reset(PtrType __p = nullptr) { + PtrType __tmp = __stor.__ptr; + __stor.__ptr = __p; + if (__tmp) __stor.get_deleter()(__tmp); } - void swap(Box &u) { - p_stor.swap(u.p_stor); + void swap(Box &__u) { + __stor.swap(__u.__stor); } private: - __OctaBoxPair p_stor; + __OctaBoxPair<_T, _D> __stor; }; - template>, - RemoveCv> - >::value> struct __OctaSameOrLessCvQualifiedBase: IsConvertible {}; + template>, + octa::RemoveCv> + >::value> struct __OctaSameOrLessCvQualifiedBase: octa::IsConvertible<_T, _U> {}; - template - struct __OctaSameOrLessCvQualifiedBase: False {}; + template + struct __OctaSameOrLessCvQualifiedBase<_T, _U, false>: octa::False {}; - template::value - || IsSame::value || __OctaHasElementType::value - > struct __OctaSameOrLessCvQualified: __OctaSameOrLessCvQualifiedBase {}; + template::value + || octa::IsSame<_T, _U>::value || __OctaHasElementType<_T>::value + > struct __OctaSameOrLessCvQualified: __OctaSameOrLessCvQualifiedBase<_T, _U> {}; - template - struct __OctaSameOrLessCvQualified: False {}; + template + struct __OctaSameOrLessCvQualified<_T, _U, false>: octa::False {}; - template - struct Box { - typedef T ElementType; - typedef D DeleterType; - typedef typename __OctaPtrType::Type PtrType; + template + struct Box<_T[], _D> { + typedef _T ElementType; + typedef _D DeleterType; + typedef typename __OctaPtrType<_T, _D>::Type PtrType; private: - struct __OctaNat { int x; }; + struct __OctaNat { int __x; }; - typedef RemoveReference &D_ref; - typedef const RemoveReference &D_cref; + typedef RemoveReference<_D> &_D_ref; + typedef const RemoveReference<_D> &_D_cref; public: - constexpr Box(): p_stor(nullptr, D()) { - static_assert(!IsPointer::value, + constexpr Box(): __stor(nullptr, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - constexpr Box(nullptr_t): p_stor(nullptr, D()) { - static_assert(!IsPointer::value, + constexpr Box(nullptr_t): __stor(nullptr, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - template explicit Box(U p, EnableIf< - __OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()): p_stor(p, D()) { - static_assert(!IsPointer::value, + template explicit Box(_U __p, octa::EnableIf< + __OctaSameOrLessCvQualified<_U, PtrType>::value, __OctaNat + > = __OctaNat()): __stor(__p, _D()) { + static_assert(!octa::IsPointer<_D>::value, "Box constructed with null fptr deleter"); } - template Box(U p, Conditional::value, - D, AddLvalueReference - > d, EnableIf<__OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()): p_stor(p, d) {} + template Box(_U __p, octa::Conditional< + octa::IsReference<_D>::value, + _D, AddLvalueReference + > __d, octa::EnableIf<__OctaSameOrLessCvQualified<_U, PtrType>::value, + __OctaNat> = __OctaNat()): __stor(__p, __d) {} - Box(nullptr_t, Conditional::value, - D, AddLvalueReference - > d): p_stor(nullptr, d) {} + Box(nullptr_t, octa::Conditional::value, + _D, AddLvalueReference + > __d): __stor(nullptr, __d) {} - template Box(U p, RemoveReference &&d, EnableIf< - __OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()): p_stor(p, move(d)) { - static_assert(!IsReference::value, + template Box(_U __p, octa::RemoveReference<_D> &&__d, + octa::EnableIf< + __OctaSameOrLessCvQualified<_U, PtrType>::value, __OctaNat + > = __OctaNat()): __stor(__p, octa::move(__d)) { + static_assert(!octa::IsReference<_D>::value, "rvalue deleter cannot be a ref"); } - Box(nullptr_t, RemoveReference &&d): p_stor(nullptr, move(d)) { - static_assert(!IsReference::value, + Box(nullptr_t, octa::RemoveReference<_D> &&__d): + __stor(nullptr, octa::move(__d)) { + static_assert(!octa::IsReference<_D>::value, "rvalue deleter cannot be a ref"); } - Box(Box &&u): p_stor(u.release(), forward(u.get_deleter())) {} + Box(Box &&__u): __stor(__u.release(), + octa::forward<_D>(__u.get_deleter())) {} - template - Box(Box &&u, EnableIf::value - && __OctaSameOrLessCvQualified::PtrType, + template + Box(Box<_TT, _DD> &&__u, EnableIf::value + && __OctaSameOrLessCvQualified::PtrType, PtrType>::value - && IsConvertible::value - && (!IsReference::value || IsSame::value)> = __OctaNat() - ): p_stor(u.release(), forward
(u.get_deleter())) {} + && octa::IsConvertible<_DD, _D>::value + && (!octa::IsReference<_D>::value || + octa::IsSame<_D, _DD>::value)> = __OctaNat() + ): __stor(__u.release(), octa::forward<_DD>(__u.get_deleter())) {} - Box &operator=(Box &&u) { - reset(u.release()); - p_stor.get_deleter() = forward(u.get_deleter()); + Box &operator=(Box &&__u) { + reset(__u.release()); + __stor.get_deleter() = octa::forward<_D>(__u.get_deleter()); return *this; } - template - EnableIf::value - && __OctaSameOrLessCvQualified::PtrType, + template + EnableIf::value + && __OctaSameOrLessCvQualified::PtrType, PtrType>::value - && IsAssignable::value, + && IsAssignable<_D &, _DD &&>::value, Box & - > operator=(Box &&u) { - reset(u.release()); - p_stor.get_deleter() = forward
(u.get_deleter()); + > operator=(Box<_TT, _DD> &&__u) { + reset(__u.release()); + __stor.get_deleter() = octa::forward<_DD>(__u.get_deleter()); return *this; } @@ -463,75 +475,75 @@ namespace octa { ~Box() { reset(); } - AddLvalueReference operator[](size_t idx) const { - return p_stor.i_ptr[idx]; + octa::AddLvalueReference<_T> operator[](size_t __idx) const { + return __stor.__ptr[__idx]; } explicit operator bool() const { - return p_stor.i_ptr != nullptr; + return __stor.__ptr != nullptr; } - PtrType get() const { return p_stor.i_ptr; } + PtrType get() const { return __stor.__ptr; } - D_ref get_deleter() { return p_stor.get_deleter(); } - D_cref get_deleter() const { return p_stor.get_deleter(); } + _D_ref get_deleter() { return __stor.get_deleter(); } + _D_cref get_deleter() const { return __stor.get_deleter(); } PtrType release() { - PtrType p = p_stor.i_ptr; - p_stor.i_ptr = nullptr; - return p; + PtrType __p = __stor.__ptr; + __stor.__ptr = nullptr; + return __p; } - template EnableIf< - __OctaSameOrLessCvQualified::value, void - > reset(U p) { - PtrType tmp = p_stor.i_ptr; - p_stor.i_ptr = p; - if (tmp) p_stor.get_deleter()(tmp); + template EnableIf< + __OctaSameOrLessCvQualified<_U, PtrType>::value, void + > reset(_U __p) { + PtrType __tmp = __stor.__ptr; + __stor.__ptr = __p; + if (__tmp) __stor.get_deleter()(__tmp); } void reset(nullptr_t) { - PtrType tmp = p_stor.i_ptr; - p_stor.i_ptr = nullptr; - if (tmp) p_stor.get_deleter()(tmp); + PtrType __tmp = __stor.__ptr; + __stor.__ptr = nullptr; + if (__tmp) __stor.get_deleter()(__tmp); } void reset() { reset(nullptr); } - void swap(Box &u) { - p_stor.swap(u.p_stor); + void swap(Box &__u) { + __stor.swap(__u.__stor); } private: - __OctaBoxPair p_stor; + __OctaBoxPair<_T, _D> __stor; }; - template struct __OctaBoxIf { - typedef Box __OctaBox; + template struct __OctaBoxIf { + typedef Box<_T> __OctaBox; }; - template struct __OctaBoxIf { - typedef Box __OctaBoxUnknownSize; + template struct __OctaBoxIf<_T[]> { + typedef Box<_T[]> __OctaBoxUnknownSize; }; - template struct __OctaBoxIf { + template struct __OctaBoxIf<_T[_N]> { typedef void __OctaBoxKnownSize; }; - template - typename __OctaBoxIf::__OctaBox make_box(A &&...args) { - return Box(new T(forward(args)...)); + template + typename __OctaBoxIf<_T>::__OctaBox make_box(_A &&...__args) { + return Box<_T>(new _T(octa::forward<_A>(__args)...)); } - template - typename __OctaBoxIf::__OctaBoxUnknownSize make_box(size_t n) { - return Box(new RemoveExtent[n]()); + template + typename __OctaBoxIf<_T>::__OctaBoxUnknownSize make_box(size_t __n) { + return Box<_T>(new octa::RemoveExtent<_T>[__n]()); } - template - typename __OctaBoxIf::__OctaBoxKnownSize make_box(A &&...args) = delete; + template + typename __OctaBoxIf<_T>::__OctaBoxKnownSize make_box(_A &&...__args) = delete; /* allocator */ @@ -542,7 +554,7 @@ namespace octa { typedef void *PtrType; typedef const void *ConstPtrType; - template using Rebind = Allocator; + template using Rebind = Allocator<_U>; }; template<> struct Allocator { @@ -550,81 +562,81 @@ namespace octa { typedef const void *PtrType; typedef const void *ConstPtrType; - template using Rebind = Allocator; + template using Rebind = Allocator<_U>; }; - template struct Allocator { - typedef size_t SizeType; - typedef ptrdiff_t DiffType; - typedef T ValType; - typedef T &RefType; - typedef const T &ConstRefType; - typedef T *PtrType; - typedef const T *ConstPtrType; + template struct Allocator { + typedef size_t SizeType; + typedef ptrdiff_t DiffType; + typedef _T ValType; + typedef _T &RefType; + typedef const _T &ConstRefType; + typedef _T *PtrType; + typedef const _T *ConstPtrType; - template using Rebind = Allocator; + template using Rebind = Allocator<_U>; - PtrType address(RefType v) const { - return address_of(v); + PtrType address(RefType __v) const { + return address_of(__v); }; - ConstPtrType address(ConstRefType v) const { - return address_of(v); + ConstPtrType address(ConstRefType __v) const { + return address_of(__v); }; - SizeType max_size() const { return SizeType(~0) / sizeof(T); } + SizeType max_size() const { return SizeType(~0) / sizeof(_T); } - PtrType allocate(SizeType n, Allocator::ConstPtrType = nullptr) { - return (PtrType) ::new uchar[n * sizeof(T)]; + PtrType allocate(SizeType __n, Allocator::ConstPtrType = nullptr) { + return (PtrType) ::new uchar[__n * sizeof(_T)]; } - void deallocate(PtrType p, SizeType) { ::delete[] (uchar *) p; } + void deallocate(PtrType __p, SizeType) { ::delete[] (uchar *) __p; } - template - void construct(U *p, A &&...args) { - ::new((void *)p) U(forward(args)...); + template + void construct(_U *__p, _A &&...__args) { + ::new((void *)__p) _U(octa::forward<_A>(__args)...); } - void destroy(PtrType p) { p->~T(); } + void destroy(PtrType __p) { __p->~_T(); } }; - template struct Allocator { - typedef size_t SizeType; - typedef ptrdiff_t DiffType; - typedef const T ValType; - typedef const T &RefType; - typedef const T &ConstRefType; - typedef const T *PtrType; - typedef const T *ConstPtrType; + template struct Allocator { + typedef size_t SizeType; + typedef ptrdiff_t DiffType; + typedef const _T ValType; + typedef const _T &RefType; + typedef const _T &ConstRefType; + typedef const _T *PtrType; + typedef const _T *ConstPtrType; - template using Rebind = Allocator; + template using Rebind = Allocator<_U>; - ConstPtrType address(ConstRefType v) const { - return address_of(v); + ConstPtrType address(ConstRefType __v) const { + return address_of(__v); }; - SizeType max_size() const { return SizeType(~0) / sizeof(T); } + SizeType max_size() const { return SizeType(~0) / sizeof(_T); } - PtrType allocate(SizeType n, Allocator::ConstPtrType = nullptr) { - return (PtrType) ::new uchar[n * sizeof(T)]; + PtrType allocate(SizeType __n, Allocator::ConstPtrType = nullptr) { + return (PtrType) ::new uchar[__n * sizeof(_T)]; } - void deallocate(PtrType p, SizeType) { ::delete[] (uchar *) p; } + void deallocate(PtrType __p, SizeType) { ::delete[] (uchar *) __p; } - template - void construct(U *p, A &&...args) { - ::new((void *)p) U(forward(args)...); + template + void construct(_U *__p, _A &&...__args) { + ::new((void *)__p) _U(octa::forward<_A>(__args)...); } - void destroy(PtrType p) { p->~T(); } + void destroy(PtrType __p) { __p->~_T(); } }; - template - bool operator==(const Allocator &, const Allocator &) { + template + bool operator==(const Allocator<_T> &, const Allocator<_U> &) { return true; } - template - bool operator!=(const Allocator &, const Allocator &) { + template + bool operator!=(const Allocator<_T> &, const Allocator<_U> &) { return false; } } diff --git a/octa/range.h b/octa/range.h index e51be95..136b2e9 100644 --- a/octa/range.h +++ b/octa/range.h @@ -20,19 +20,19 @@ namespace octa { struct RandomAccessRangeTag: BidirectionalRangeTag {}; struct FiniteRandomAccessRangeTag: RandomAccessRangeTag {}; - template struct RangeHalf; + template struct RangeHalf; -#define __OCTA_RANGE_TRAIT(Name, TypeName) \ - template \ - struct __OctaRange##Name { \ - typedef typename T::TypeName Type; \ +#define __OCTA_RANGE_TRAIT(_Name, _TypeName) \ + template \ + struct __OctaRange##_Name { \ + typedef typename _T::_TypeName Type; \ }; \ - template \ - struct __OctaRange##Name> { \ - typedef typename T::TypeName Type; \ + template \ + struct __OctaRange##_Name> { \ + typedef typename _T::_TypeName Type; \ }; \ - template \ - using Range##Name = typename __OctaRange##Name::Type; + template \ + using Range##_Name = typename __OctaRange##_Name<_T>::Type; __OCTA_RANGE_TRAIT(Category, Category) __OCTA_RANGE_TRAIT(Size, SizeType) @@ -44,157 +44,157 @@ namespace octa { // is input range - template, InputRangeTag + template, InputRangeTag >::value> struct IsInputRange: False {}; - template - struct IsInputRange: True {}; + template + struct IsInputRange<_T, true>: True {}; // is forward range - template, ForwardRangeTag + template, ForwardRangeTag >::value> struct IsForwardRange: False {}; - template - struct IsForwardRange: True {}; + template + struct IsForwardRange<_T, true>: True {}; // is bidirectional range - template, BidirectionalRangeTag + template, BidirectionalRangeTag >::value> struct IsBidirectionalRange: False {}; - template - struct IsBidirectionalRange: True {}; + template + struct IsBidirectionalRange<_T, true>: True {}; // is random access range - template, RandomAccessRangeTag + template, RandomAccessRangeTag >::value> struct IsRandomAccessRange: False {}; - template - struct IsRandomAccessRange: True {}; + template + struct IsRandomAccessRange<_T, true>: True {}; // is finite random access range - template, FiniteRandomAccessRangeTag + template, FiniteRandomAccessRangeTag >::value> struct IsFiniteRandomAccessRange: False {}; - template - struct IsFiniteRandomAccessRange: True {}; + template + struct IsFiniteRandomAccessRange<_T, true>: True {}; // is infinite random access range - template + template struct IsInfiniteRandomAccessRange: IntegralConstant::value && !IsFiniteRandomAccessRange::value) + (IsRandomAccessRange<_T>::value && !IsFiniteRandomAccessRange<_T>::value) > {}; // is output range - template + template struct __OctaOutputRangeTest { - template struct __OctaTest {}; - template static char __octa_test(__OctaTest *); - template static int __octa_test(...); - static constexpr bool value = (sizeof(__octa_test(0)) == sizeof(char)); + template struct __Test {}; + template static char __test(__Test<_U, &_U::put> *); + template static int __test(...); + static constexpr bool value = (sizeof(__test<_T>(0)) == sizeof(char)); }; - template, OutputRangeTag - >::value || (IsInputRange::value && - (__OctaOutputRangeTest &>::value || - __OctaOutputRangeTest &&>::value) + template, OutputRangeTag + >::value || (IsInputRange<_T>::value && + (__OctaOutputRangeTest<_T, const RangeValue<_T> &>::value || + __OctaOutputRangeTest<_T, RangeValue<_T> &&>::value) ))> struct IsOutputRange: False {}; - template - struct IsOutputRange: True {}; + template + struct IsOutputRange<_T, true>: True {}; // range iterator - template + template struct __OctaRangeIterator { - __OctaRangeIterator(): p_range() {} - explicit __OctaRangeIterator(const T &range): p_range(range) {} + __OctaRangeIterator(): __range() {} + explicit __OctaRangeIterator(const _T &__range): __range(__range) {} __OctaRangeIterator &operator++() { - p_range.pop_front(); + __range.pop_front(); return *this; } - RangeReference operator*() const { - return p_range.front(); + RangeReference<_T> operator*() const { + return __range.front(); } - bool operator!=(__OctaRangeIterator) const { return !p_range.empty(); } + bool operator!=(__OctaRangeIterator) const { return !__range.empty(); } private: - T p_range; + _T __range; }; // range half - template + template struct RangeHalf { private: - T p_range; + _T __range; public: - typedef T RangeType; + typedef _T RangeType; - RangeHalf(): p_range() {} - RangeHalf(const T &range): p_range(range) {} - RangeHalf(const RangeHalf &half): p_range(half.p_range) {} - RangeHalf(RangeHalf &&half): p_range(move(half.p_range)) {} + RangeHalf(): __range() {} + RangeHalf(const _T &__range): __range(__range) {} + RangeHalf(const RangeHalf &__half): __range(__half.__range) {} + RangeHalf(RangeHalf &&__half): __range(octa::move(__half.__range)) {} - RangeHalf &operator=(const RangeHalf &half) { - p_range = half.p_range; + RangeHalf &operator=(const RangeHalf &__half) { + __range = __half.__range; return *this; } - RangeHalf &operator=(RangeHalf &&half) { - p_range = move(half.p_range); + RangeHalf &operator=(RangeHalf &&__half) { + __range = octa::move(__half.__range); return *this; } - T range() const { return p_range; } + _T range() const { return __range; } - bool next() { return p_range.pop_front(); } - bool prev() { return p_range.push_front(); } + bool next() { return __range.pop_front(); } + bool prev() { return __range.push_front(); } - RangeSize next_n(RangeSize n) { - return p_range.pop_front_n(n); + RangeSize<_T> next_n(RangeSize<_T> __n) { + return __range.pop_front_n(__n); } - RangeSize prev_n(RangeSize n) { - return p_range.push_front_n(n); + RangeSize<_T> prev_n(RangeSize<_T> __n) { + return __range.push_front_n(__n); } - RangeReference get() const { - return p_range.front(); + RangeReference<_T> get() const { + return __range.front(); } - RangeDifference distance(const RangeHalf &half) const { - return p_range.distance_front(half.p_range); + RangeDifference<_T> distance(const RangeHalf &__half) const { + return __range.distance_front(__half.__range); } - bool equals(const RangeHalf &half) const { - return p_range.equals_front(half.p_range); + bool equals(const RangeHalf &__half) const { + return __range.equals_front(__half.__range); } - bool operator==(const RangeHalf &half) const { - return equals(half); + bool operator==(const RangeHalf &__half) const { + return equals(__half); } - bool operator!=(const RangeHalf &half) const { - return !equals(half); + bool operator!=(const RangeHalf &__half) const { + return !equals(__half); } /* iterator like interface */ - RangeReference operator*() const { + RangeReference<_T> operator*() const { return get(); } - RangeReference operator[](RangeSize idx) const { - return p_range[idx]; + RangeReference<_T> operator[](RangeSize<_T> __idx) const { + return __range[__idx]; } RangeHalf &operator++() { @@ -202,9 +202,9 @@ namespace octa { return *this; } RangeHalf operator++(int) { - RangeHalf tmp(*this); + RangeHalf __tmp(*this); next(); - return move(tmp); + return octa::move(__tmp); } RangeHalf &operator--() { @@ -212,738 +212,744 @@ namespace octa { return *this; } RangeHalf operator--(int) { - RangeHalf tmp(*this); + RangeHalf __tmp(*this); prev(); - return move(tmp); + return octa::move(__tmp); } - RangeHalf operator+(RangeDifference n) { - RangeHalf tmp(*this); - if (n < 0) tmp.prev_n(-n); - else tmp.next_n(n); - return move(tmp); + RangeHalf operator+(RangeDifference<_T> __n) { + RangeHalf __tmp(*this); + if (__n < 0) __tmp.prev_n(-__n); + else __tmp.next_n(__n); + return octa::move(__tmp); } - RangeHalf operator-(RangeDifference n) { - RangeHalf tmp(*this); - if (n < 0) tmp.next_n(-n); - else tmp.prev_n(n); - return move(tmp); + RangeHalf operator-(RangeDifference<_T> __n) { + RangeHalf __tmp(*this); + if (__n < 0) __tmp.next_n(-__n); + else __tmp.prev_n(__n); + return octa::move(__tmp); } - RangeHalf &operator+=(RangeDifference n) { - if (n < 0) prev_n(-n); - else next_n(n); + RangeHalf &operator+=(RangeDifference<_T> __n) { + if (__n < 0) prev_n(-__n); + else next_n(__n); return *this; } - RangeHalf &operator-=(RangeDifference n) { - if (n < 0) next_n(-n); - else prev_n(n); + RangeHalf &operator-=(RangeDifference<_T> __n) { + if (__n < 0) next_n(-__n); + else prev_n(__n); return *this; } }; - template - RangeDifference operator-(const R &lhs, const R &rhs) { - return rhs.distance(lhs); + template + RangeDifference<_R> operator-(const _R &__lhs, const _R &__rhs) { + return __rhs.distance(__lhs); } - template - RangeSize __octa_pop_front_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) - if (!range.pop_front()) return i; - return n; + template + RangeSize<_R> __octa_pop_front_n(_R &__range, RangeSize<_R> __n) { + for (RangeSize<_R> __i = 0; __i < __n; ++__i) + if (!__range.pop_front()) return __i; + return __n; } - template - RangeSize __octa_pop_back_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) - if (!range.pop_back()) return i; - return n; + template + RangeSize<_R> __octa_pop_back_n(_R &__range, RangeSize<_R> __n) { + for (RangeSize<_R> __i = 0; __i < __n; ++__i) + if (!__range.pop_back()) return __i; + return __n; } - template - RangeSize __octa_push_front_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) - if (!range.push_front()) return i; - return n; + template + RangeSize<_R> __octa_push_front_n(_R &__range, RangeSize<_R> __n) { + for (RangeSize<_R> __i = 0; __i < __n; ++__i) + if (!__range.push_front()) return __i; + return __n; } - template - RangeSize __octa_push_back_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) - if (!range.push_back()) return i; - return n; + template + RangeSize<_R> __octa_push_back_n(_R &__range, RangeSize<_R> __n) { + for (RangeSize<_R> __i = 0; __i < __n; ++__i) + if (!__range.push_back()) return __i; + return __n; } - template struct InputRange { - typedef C Category; - typedef S SizeType; - typedef D DiffType; - typedef V ValType; - typedef R RefType; + typedef _C Category; + typedef _S SizeType; + typedef _D DiffType; + typedef _V ValType; + typedef _R RefType; - __OctaRangeIterator begin() const { - return __OctaRangeIterator((const B &)*this); + __OctaRangeIterator<_B> begin() const { + return __OctaRangeIterator<_B>((const _B &)*this); } - __OctaRangeIterator end() const { - return __OctaRangeIterator(); + __OctaRangeIterator<_B> end() const { + return __OctaRangeIterator<_B>(); } - SizeType pop_front_n(SizeType n) { - return __octa_pop_front_n(*((B *)this), n); + SizeType pop_front_n(SizeType __n) { + return __octa_pop_front_n<_B>(*((_B *)this), __n); } - SizeType pop_back_n(SizeType n) { - return __octa_pop_back_n(*((B *)this), n); + SizeType pop_back_n(SizeType __n) { + return __octa_pop_back_n<_B>(*((_B *)this), __n); } - SizeType push_front_n(SizeType n) { - return __octa_push_front_n(*((B *)this), n); + SizeType push_front_n(SizeType __n) { + return __octa_push_front_n<_B>(*((_B *)this), __n); } - SizeType push_back_n(SizeType n) { - return __octa_push_back_n(*((B *)this), n); + SizeType push_back_n(SizeType __n) { + return __octa_push_back_n<_B>(*((_B *)this), __n); } - B each() const { - return B(*((B *)this)); + _B each() const { + return _B(*((_B *)this)); } - RangeHalf half() const { - return RangeHalf(*((B *)this)); + RangeHalf<_B> half() const { + return RangeHalf<_B>(*((_B *)this)); } }; - template struct OutputRange { typedef OutputRangeTag Category; - typedef S SizeType; - typedef D DiffType; - typedef V ValType; - typedef R RefType; + typedef _S SizeType; + typedef _D DiffType; + typedef _V ValType; + typedef _R RefType; }; - template - struct ReverseRange: InputRange, - RangeCategory, RangeValue, RangeReference, RangeSize, - RangeDifference + template + struct ReverseRange: InputRange, + RangeCategory<_T>, RangeValue<_T>, RangeReference<_T>, RangeSize<_T>, + RangeDifference<_T> > { private: - typedef RangeReference r_ref; - typedef RangeSize r_size; + typedef RangeReference<_T> _r_ref; + typedef RangeSize<_T> _r_size; - T p_range; + _T __range; public: - ReverseRange(): p_range() {} + ReverseRange(): __range() {} - ReverseRange(const T &range): p_range(range) {} + ReverseRange(const _T &__range): __range(__range) {} - ReverseRange(const ReverseRange &it): p_range(it.p_range) {} + ReverseRange(const ReverseRange &__it): __range(__it.__range) {} - ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {} + ReverseRange(ReverseRange &&__it): __range(octa::move(__it.__range)) {} - ReverseRange &operator=(const ReverseRange &v) { - p_range = v.p_range; + ReverseRange &operator=(const ReverseRange &__v) { + __range = __v.__range; return *this; } - ReverseRange &operator=(ReverseRange &&v) { - p_range = move(v.p_range); + ReverseRange &operator=(ReverseRange &&__v) { + __range = octa::move(__v.__range); return *this; } - ReverseRange &operator=(const T &v) { - p_range = v; + ReverseRange &operator=(const _T &__v) { + __range = __v; return *this; } - ReverseRange &operator=(T &&v) { - p_range = move(v); + ReverseRange &operator=(_T &&__v) { + __range = octa::move(__v); return *this; } - bool empty() const { return p_range.empty(); } - r_size size() const { return p_range.size(); } + bool empty() const { return __range.empty(); } + _r_size size() const { return __range.size(); } - bool equals_front(const ReverseRange &range) const { - return p_range.equals_back(range.p_range); + bool equals_front(const ReverseRange &__r) const { + return __range.equals_back(__r.__range); } - bool equals_back(const ReverseRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_back(const ReverseRange &__r) const { + return __range.equals_front(__r.__range); } - RangeDifference distance_front(const ReverseRange &range) const { - return -p_range.distance_back(range.p_range); + RangeDifference<_T> distance_front(const ReverseRange &__r) const { + return -__range.distance_back(__r.__range); } - RangeDifference distance_back(const ReverseRange &range) const { - return -p_range.distance_front(range.p_range); + RangeDifference<_T> distance_back(const ReverseRange &__r) const { + return -__range.distance_front(__r.__range); } - bool pop_front() { return p_range.pop_back(); } - bool pop_back() { return p_range.pop_front(); } + bool pop_front() { return __range.pop_back(); } + bool pop_back() { return __range.pop_front(); } - bool push_front() { return p_range.push_back(); } - bool push_back() { return p_range.push_front(); } + bool push_front() { return __range.push_back(); } + bool push_back() { return __range.push_front(); } - r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); } - r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); } + _r_size pop_front_n(_r_size __n) { return __range.pop_front_n(__n); } + _r_size pop_back_n(_r_size __n) { return __range.pop_back_n(__n); } - r_size push_front_n(r_size n) { return p_range.push_front_n(n); } - r_size push_back_n(r_size n) { return p_range.push_back_n(n); } + _r_size push_front_n(_r_size __n) { return __range.push_front_n(__n); } + _r_size push_back_n(_r_size __n) { return __range.push_back_n(__n); } - r_ref front() const { return p_range.back(); } - r_ref back() const { return p_range.front(); } + _r_ref front() const { return __range.back(); } + _r_ref back() const { return __range.front(); } - r_ref operator[](r_size i) const { return p_range[size() - i - 1]; } + _r_ref operator[](_r_size __i) const { return __range[size() - __i - 1]; } - ReverseRange slice(r_size start, r_size end) const { - r_size len = p_range.size(); - return ReverseRange(p_range.slice(len - end, len - start)); + ReverseRange<_T> slice(_r_size __start, _r_size __end) const { + _r_size __len = __range.size(); + return ReverseRange<_T>(__range.slice(__len - __end, __len - __start)); } }; - template - ReverseRange make_reverse_range(const T &it) { - return ReverseRange(it); + template + ReverseRange<_T> make_reverse_range(const _T &__it) { + return ReverseRange<_T>(__it); } - template - struct MoveRange: InputRange, - RangeCategory, RangeValue, RangeValue &&, RangeSize, - RangeDifference + template + struct MoveRange: InputRange, + RangeCategory<_T>, RangeValue<_T>, RangeValue<_T> &&, RangeSize<_T>, + RangeDifference<_T> > { private: - typedef RangeValue r_val; - typedef RangeValue &&r_ref; - typedef RangeSize r_size; + typedef RangeValue<_T> _r_val; + typedef RangeValue<_T> &&_r_ref; + typedef RangeSize<_T> _r_size; - T p_range; + _T __range; public: - MoveRange(): p_range() {} + MoveRange(): __range() {} - MoveRange(const T &range): p_range(range) {} + MoveRange(const _T &__range): __range(__range) {} - MoveRange(const MoveRange &it): p_range(it.p_range) {} + MoveRange(const MoveRange &__it): __range(__it.__range) {} - MoveRange(MoveRange &&it): p_range(move(it.p_range)) {} + MoveRange(MoveRange &&__it): __range(octa::move(__it.__range)) {} - MoveRange &operator=(const MoveRange &v) { - p_range = v.p_range; + MoveRange &operator=(const MoveRange &__v) { + __range = __v.__range; return *this; } - MoveRange &operator=(MoveRange &&v) { - p_range = move(v.p_range); + MoveRange &operator=(MoveRange &&__v) { + __range = octa::move(__v.__range); return *this; } - MoveRange &operator=(const T &v) { - p_range = v; + MoveRange &operator=(const _T &__v) { + __range = __v; return *this; } - MoveRange &operator=(T &&v) { - p_range = move(v); + MoveRange &operator=(_T &&__v) { + __range = octa::move(__v); return *this; } - bool empty() const { return p_range.empty(); } - r_size size() const { return p_range.size(); } + bool empty() const { return __range.empty(); } + _r_size size() const { return __range.size(); } - bool equals_front(const MoveRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const MoveRange &__r) const { + return __range.equals_front(__r.__range); } - bool equals_back(const MoveRange &range) const { - return p_range.equals_back(range.p_range); + bool equals_back(const MoveRange &__r) const { + return __range.equals_back(__r.__range); } - RangeDifference distance_front(const MoveRange &range) const { - return p_range.distance_front(range.p_range); + RangeDifference<_T> distance_front(const MoveRange &__r) const { + return __range.distance_front(__r.__range); } - RangeDifference distance_back(const MoveRange &range) const { - return p_range.distance_back(range.p_range); + RangeDifference<_T> distance_back(const MoveRange &__r) const { + return __range.distance_back(__r.__range); } - bool pop_front() { return p_range.pop_front(); } - bool pop_back() { return p_range.pop_back(); } + bool pop_front() { return __range.pop_front(); } + bool pop_back() { return __range.pop_back(); } - bool push_front() { return p_range.push_front(); } - bool push_back() { return p_range.push_back(); } + bool push_front() { return __range.push_front(); } + bool push_back() { return __range.push_back(); } - r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); } - r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); } + _r_size pop_front_n(_r_size __n) { return __range.pop_front_n(__n); } + _r_size pop_back_n(_r_size __n) { return __range.pop_back_n(__n); } - r_size push_front_n(r_size n) { return p_range.push_front_n(n); } - r_size push_back_n(r_size n) { return p_range.push_back_n(n); } + _r_size push_front_n(_r_size __n) { return __range.push_front_n(__n); } + _r_size push_back_n(_r_size __n) { return __range.push_back_n(__n); } - r_ref front() const { return move(p_range.front()); } - r_ref back() const { return move(p_range.back()); } + _r_ref front() const { return octa::move(__range.front()); } + _r_ref back() const { return octa::move(__range.back()); } - r_ref operator[](r_size i) const { return move(p_range[i]); } + _r_ref operator[](_r_size __i) const { return octa::move(__range[__i]); } - MoveRange slice(r_size start, r_size end) const { - return MoveRange(p_range.slice(start, end)); + MoveRange<_T> slice(_r_size __start, _r_size __end) const { + return MoveRange<_T>(__range.slice(__start, __end)); } - void put(const r_val &v) { p_range.put(v); } - void put(r_val &&v) { p_range.put(move(v)); } + void put(const _r_val &__v) { __range.put(__v); } + void put(_r_val &&__v) { __range.put(octa::move(__v)); } }; - template - MoveRange make_move_range(const T &it) { - return MoveRange(it); + template + MoveRange<_T> make_move_range(const _T &__it) { + return MoveRange<_T>(__it); } - template - struct NumberRange: InputRange, ForwardRangeTag, T, T> { - NumberRange(): p_a(0), p_b(0), p_step(0) {} - NumberRange(const NumberRange &it): p_a(it.p_a), p_b(it.p_b), - p_step(it.p_step) {} - NumberRange(T a, T b, T step = T(1)): p_a(a), p_b(b), - p_step(step) {} - NumberRange(T v): p_a(0), p_b(v), p_step(1) {} + template + struct NumberRange: InputRange, ForwardRangeTag, _T, _T> { + NumberRange(): __a(0), __b(0), __step(0) {} + NumberRange(const NumberRange &__it): __a(__it.__a), __b(__it.__b), + __step(__it.__step) {} + NumberRange(_T __a, _T __b, _T __step = _T(1)): __a(__a), __b(__b), + __step(__step) {} + NumberRange(_T __v): __a(0), __b(__v), __step(1) {} - bool empty() const { return p_a * p_step >= p_b * p_step; } + bool empty() const { return __a * __step >= __b * __step; } - bool equals_front(const NumberRange &range) const { - return p_a == range.p_a; + bool equals_front(const NumberRange &__range) const { + return __a == __range.__a; } - bool pop_front() { p_a += p_step; return true; } - bool push_front() { p_a -= p_step; return true; } - T front() const { return p_a; } + bool pop_front() { __a += __step; return true; } + bool push_front() { __a -= __step; return true; } + _T front() const { return __a; } private: - T p_a, p_b, p_step; + _T __a, __b, __step; }; - template - NumberRange range(T a, T b, T step = T(1)) { - return NumberRange(a, b, step); + template + NumberRange<_T> range(_T __a, _T __b, _T __step = _T(1)) { + return NumberRange<_T>(__a, __b, __step); } - template - NumberRange range(T v) { - return NumberRange(v); + template + NumberRange<_T> range(_T __v) { + return NumberRange<_T>(__v); } - template - struct PointerRange: InputRange, FiniteRandomAccessRangeTag, T> { - PointerRange(): p_beg(nullptr), p_end(nullptr) {} - PointerRange(const PointerRange &v): p_beg(v.p_beg), - p_end(v.p_end) {} - PointerRange(T *beg, T *end): p_beg(beg), p_end(end) {} - PointerRange(T *beg, size_t n): p_beg(beg), p_end(beg + n) {} + template + struct PointerRange: InputRange, FiniteRandomAccessRangeTag, _T> { + PointerRange(): __beg(nullptr), __end(nullptr) {} + PointerRange(const PointerRange &__v): __beg(__v.__beg), + __end(__v.__end) {} + PointerRange(_T *__beg, _T *__end): __beg(__beg), __end(__end) {} + PointerRange(_T *__beg, size_t __n): __beg(__beg), __end(__beg + __n) {} - PointerRange &operator=(const PointerRange &v) { - p_beg = v.p_beg; - p_end = v.p_end; + PointerRange &operator=(const PointerRange &__v) { + __beg = __v.__beg; + __end = __v.__end; return *this; } /* satisfy InputRange / ForwardRange */ - bool empty() const { return p_beg == p_end; } + bool empty() const { return __beg == __end; } bool pop_front() { - if (p_beg == p_end) return false; - ++p_beg; + if (__beg == __end) return false; + ++__beg; return true; } bool push_front() { - --p_beg; return true; + --__beg; return true; } - size_t pop_front_n(size_t n) { - size_t olen = p_end - p_beg; - p_beg += n; - if (p_beg > p_end) { - p_beg = p_end; - return olen; + size_t pop_front_n(size_t __n) { + size_t __olen = __end - __beg; + __beg += __n; + if (__beg > __end) { + __beg = __end; + return __olen; } - return n; + return __n; } - size_t push_front_n(size_t n) { - p_beg -= n; return true; + size_t push_front_n(size_t __n) { + __beg -= __n; return true; } - T &front() const { return *p_beg; } + _T &front() const { return *__beg; } - bool equals_front(const PointerRange &range) const { - return p_beg == range.p_beg; + bool equals_front(const PointerRange &__range) const { + return __beg == __range.__beg; } - ptrdiff_t distance_front(const PointerRange &range) const { - return range.p_beg; + ptrdiff_t distance_front(const PointerRange &__range) const { + return __range.__beg - __beg; } /* satisfy BidirectionalRange */ bool pop_back() { - if (p_end == p_beg) return false; - --p_end; + if (__end == __beg) return false; + --__end; return true; } bool push_back() { - ++p_end; return true; + ++__end; return true; } - size_t pop_back_n(size_t n) { - size_t olen = p_end - p_beg; - p_end -= n; - if (p_end < p_beg) { - p_end = p_beg; - return olen; + size_t pop_back_n(size_t __n) { + size_t __olen = __end - __beg; + __end -= __n; + if (__end < __beg) { + __end = __beg; + return __olen; } - return n; + return __n; } - size_t push_back_n(size_t n) { - p_end += n; return true; + size_t push_back_n(size_t __n) { + __end += __n; return true; } - T &back() const { return *(p_end - 1); } + _T &back() const { return *(__end - 1); } - bool equals_back(const PointerRange &range) const { - return p_end == range.p_end; + bool equals_back(const PointerRange &__range) const { + return __end == __range.__end; } - ptrdiff_t distance_back(const PointerRange &range) const { - return range.p_end; + ptrdiff_t distance_back(const PointerRange &__range) const { + return __range.__end - __end; } /* satisfy FiniteRandomAccessRange */ - size_t size() const { return p_end - p_beg; } + size_t size() const { return __end - __beg; } - PointerRange slice(size_t start, size_t end) const { - return PointerRange(p_beg + start, p_beg + end); + PointerRange slice(size_t __start, size_t __end) const { + return PointerRange(__beg + __start, __beg + __end); } - T &operator[](size_t i) const { return p_beg[i]; } + _T &operator[](size_t __i) const { return __beg[__i]; } /* satisfy OutputRange */ - void put(const T &v) { - *(p_beg++) = v; + void put(const _T &__v) { + *(__beg++) = __v; } - void put(T &&v) { - *(p_beg++) = move(v); + void put(_T &&__v) { + *(__beg++) = octa::move(__v); } private: - T *p_beg, *p_end; + _T *__beg, *__end; }; - template + template struct EnumeratedValue { - S index; - T value; + _S index; + _T value; }; - template - struct EnumeratedRange: InputRange, - CommonType, ForwardRangeTag>, RangeValue, - EnumeratedValue, RangeSize>, - RangeSize + template + struct EnumeratedRange: InputRange, + CommonType, ForwardRangeTag>, RangeValue<_T>, + EnumeratedValue, RangeSize<_T>>, + RangeSize<_T> > { private: - typedef RangeReference r_ref; - typedef RangeSize r_size; + typedef RangeReference<_T> _r_ref; + typedef RangeSize<_T> _r_size; - T p_range; - r_size p_index; + _T __range; + _r_size __index; public: - EnumeratedRange(): p_range(), p_index(0) {} + EnumeratedRange(): __range(), __index(0) {} - EnumeratedRange(const T &range): p_range(range), p_index(0) {} + EnumeratedRange(const _T &__range): __range(__range), __index(0) {} - EnumeratedRange(const EnumeratedRange &it): - p_range(it.p_range), p_index(it.p_index) {} + EnumeratedRange(const EnumeratedRange &__it): + __range(__it.__range), __index(__it.__index) {} - EnumeratedRange(EnumeratedRange &&it): - p_range(move(it.p_range)), p_index(it.p_index) {} + EnumeratedRange(EnumeratedRange &&__it): + __range(octa::move(__it.__range)), __index(__it.__index) {} - EnumeratedRange &operator=(const EnumeratedRange &v) { - p_range = v.p_range; - p_index = v.p_index; + EnumeratedRange &operator=(const EnumeratedRange &__v) { + __range = __v.__range; + __index = __v.__index; return *this; } - EnumeratedRange &operator=(EnumeratedRange &&v) { - p_range = move(v.p_range); - p_index = v.p_index; + EnumeratedRange &operator=(EnumeratedRange &&__v) { + __range = octa::move(__v.__range); + __index = __v.__index; return *this; } - EnumeratedRange &operator=(const T &v) { - p_range = v; - p_index = 0; + EnumeratedRange &operator=(const _T &__v) { + __range = __v; + __index = 0; return *this; } - EnumeratedRange &operator=(T &&v) { - p_range = move(v); - p_index = 0; + EnumeratedRange &operator=(_T &&__v) { + __range = octa::move(__v); + __index = 0; return *this; } - bool empty() const { return p_range.empty(); } + bool empty() const { return __range.empty(); } - bool equals_front(const EnumeratedRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const EnumeratedRange &__r) const { + return __range.equals_front(__r.__range); } bool pop_front() { - if (p_range.pop_front()) { - ++p_index; + if (__range.pop_front()) { + ++__index; return true; } return false; } - r_size pop_front_n(r_size n) { - r_size ret = p_range.pop_front_n(n); - p_index += ret; - return ret; + _r_size pop_front_n(_r_size __n) { + _r_size __ret = __range.pop_front_n(__n); + __index += __ret; + return __ret; } - EnumeratedValue front() const { - return EnumeratedValue { p_index, p_range.front() }; + EnumeratedValue<_r_ref, _r_size> front() const { + return EnumeratedValue<_r_ref, _r_size> { __index, __range.front() }; } }; - template - EnumeratedRange enumerate(const T &it) { - return EnumeratedRange(it); + template + EnumeratedRange<_T> enumerate(const _T &__it) { + return EnumeratedRange<_T>(__it); } - template - struct TakeRange: InputRange, - CommonType, ForwardRangeTag>, - RangeValue, RangeReference, RangeSize + template + struct TakeRange: InputRange, + CommonType, ForwardRangeTag>, + RangeValue<_T>, RangeReference<_T>, RangeSize<_T> > { private: - T p_range; - RangeSize p_remaining; + _T __range; + RangeSize<_T> __remaining; public: - TakeRange(): p_range(), p_remaining(0) {} - TakeRange(const T &range, RangeSize rem): p_range(range), - p_remaining(rem) {} - TakeRange(const TakeRange &it): p_range(it.p_range), - p_remaining(it.p_remaining) {} - TakeRange(TakeRange &&it): p_range(move(it.p_range)), - p_remaining(it.p_remaining) {} + TakeRange(): __range(), __remaining(0) {} + TakeRange(const _T &__range, RangeSize<_T> __rem): __range(__range), + __remaining(__rem) {} + TakeRange(const TakeRange &__it): __range(__it.__range), + __remaining(__it.__remaining) {} + TakeRange(TakeRange &&__it): __range(octa::move(__it.__range)), + __remaining(__it.__remaining) {} - TakeRange &operator=(const TakeRange &v) { - p_range = v.p_range; p_remaining = v.p_remaining; return *this; + TakeRange &operator=(const TakeRange &__v) { + __range = __v.__range; __remaining = __v.__remaining; return *this; } - TakeRange &operator=(TakeRange &&v) { - p_range = move(v.p_range); p_remaining = v.p_remaining; return *this; + TakeRange &operator=(TakeRange &&__v) { + __range = octa::move(__v.__range); + __remaining = __v.__remaining; + return *this; } - bool empty() const { return (p_remaining <= 0) || p_range.empty(); } + bool empty() const { return (__remaining <= 0) || __range.empty(); } bool pop_front() { - if (p_range.pop_front()) { - --p_remaining; + if (__range.pop_front()) { + --__remaining; return true; } return false; } bool push_front() { - if (p_range.push_front()) { - ++p_remaining; + if (__range.push_front()) { + ++__remaining; return true; } return false; } - RangeSize pop_front_n(RangeSize n) { - RangeSize ret = p_range.pop_front_n(n); - p_remaining -= ret; - return ret; + RangeSize<_T> pop_front_n(RangeSize<_T> __n) { + RangeSize<_T> __ret = __range.pop_front_n(__n); + __remaining -= __ret; + return __ret; } - RangeSize push_front_n(RangeSize n) { - RangeSize ret = p_range.push_front_n(n); - p_remaining += ret; - return ret; + RangeSize<_T> push_front_n(RangeSize<_T> __n) { + RangeSize<_T> __ret = __range.push_front_n(__n); + __remaining += __ret; + return __ret; } - RangeReference front() const { return p_range.front(); } + RangeReference<_T> front() const { return __range.front(); } - bool equals_front(const TakeRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const TakeRange &__r) const { + return __range.equals_front(__r.__range); } - RangeDifference distance_front(const TakeRange &range) const { - return p_range.distance_front(range.p_range); + RangeDifference<_T> distance_front(const TakeRange &__r) const { + return __range.distance_front(__r.__range); } }; - template - TakeRange take(const T &it, RangeSize n) { - return TakeRange(it, n); + template + TakeRange<_T> take(const _T &__it, RangeSize<_T> __n) { + return TakeRange<_T>(__it, __n); } - template - struct ChunksRange: InputRange, - CommonType, ForwardRangeTag>, - TakeRange, TakeRange, RangeSize + template + struct ChunksRange: InputRange, + CommonType, ForwardRangeTag>, + TakeRange<_T>, TakeRange<_T>, RangeSize<_T> > { private: - T p_range; - RangeSize p_chunksize; + _T __range; + RangeSize<_T> __chunksize; public: - ChunksRange(): p_range(), p_chunksize(0) {} - ChunksRange(const T &range, RangeSize chs): p_range(range), - p_chunksize(chs) {} - ChunksRange(const ChunksRange &it): p_range(it.p_range), - p_chunksize(it.p_chunksize) {} - ChunksRange(ChunksRange &&it): p_range(move(it.p_range)), - p_chunksize(it.p_chunksize) {} + ChunksRange(): __range(), __chunksize(0) {} + ChunksRange(const _T &__range, RangeSize<_T> __chs): __range(__range), + __chunksize(__chs) {} + ChunksRange(const ChunksRange &__it): __range(__it.__range), + __chunksize(__it.__chunksize) {} + ChunksRange(ChunksRange &&__it): __range(octa::move(__it.__range)), + __chunksize(__it.__chunksize) {} - ChunksRange &operator=(const ChunksRange &v) { - p_range = v.p_range; p_chunksize = v.p_chunksize; return *this; + ChunksRange &operator=(const ChunksRange &__v) { + __range = __v.__range; __chunksize = __v.p_chunksize; return *this; } - ChunksRange &operator=(ChunksRange &&v) { - p_range = move(v.p_range); p_chunksize = v.p_chunksize; return *this; + ChunksRange &operator=(ChunksRange &&__v) { + __range = octa::move(__v.__range); + __chunksize = __v.__chunksize; + return *this; } - bool empty() const { return p_range.empty(); } + bool empty() const { return __range.empty(); } - bool equals_front(const ChunksRange &range) const { - return p_range.equals_front(range.p_range); + bool equals_front(const ChunksRange &__r) const { + return __range.equals_front(__r.__range); } - bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; } + bool pop_front() { return __range.pop_front_n(__chunksize) > 0; } bool push_front() { - T tmp = p_range; - RangeSize an = tmp.push_front_n(p_chunksize); - if (an != p_chunksize) return false; - p_range = tmp; + _T __tmp = __range; + RangeSize<_T> __an = __tmp.push_front_n(__chunksize); + if (__an != __chunksize) return false; + __range = __tmp; return true; } - RangeSize pop_front_n(RangeSize n) { - return p_range.pop_front_n(p_chunksize * n) / p_chunksize; + RangeSize<_T> pop_front_n(RangeSize<_T> __n) { + return __range.pop_front_n(__chunksize * __n) / __chunksize; } - RangeSize push_front_n(RangeSize n) { - T tmp = p_range; - RangeSize an = tmp.push_front_n(p_chunksize * n); - RangeSize pn = an / p_chunksize; - if (!pn) return 0; - if (pn == n) { - p_range = tmp; - return pn; + RangeSize<_T> push_front_n(RangeSize<_T> __n) { + _T __tmp = __range; + RangeSize<_T> __an = __tmp.push_front_n(__chunksize * __n); + RangeSize<_T> __pn = __an / __chunksize; + if (!__pn) return 0; + if (__pn == __n) { + __range = __tmp; + return __pn; } - return p_range.push_front_n(p_chunksize * an) / p_chunksize; + return __range.push_front_n(__chunksize * __an) / __chunksize; } - TakeRange front() const { return take(p_range, p_chunksize); } + TakeRange<_T> front() const { return take(__range, __chunksize); } }; - template - ChunksRange chunks(const T &it, RangeSize chs) { - return ChunksRange(it, chs); + template + ChunksRange<_T> chunks(const _T &__it, RangeSize<_T> __chs) { + return ChunksRange<_T>(__it, __chs); } - template - auto each(T &r) -> decltype(r.each()) { - return r.each(); + template + auto each(_T &__r) -> decltype(__r.each()) { + return __r.each(); } - template - auto each(const T &r) -> decltype(r.each()) { - return r.each(); + template + auto each(const _T &__r) -> decltype(__r.each()) { + return __r.each(); } - template - PointerRange each(T (&array)[N]) { - return PointerRange(array, N); + template + PointerRange<_T> each(_T (&__array)[_N]) { + return PointerRange<_T>(__array, _N); } // range of - template using RangeOf = decltype(each(declval())); + template using RangeOf = decltype(octa::each(octa::declval<_T>())); - template - struct HalfRange: InputRange, - RangeCategory, RangeValue, RangeReference, RangeSize, - RangeDifference + template + struct HalfRange: InputRange, + RangeCategory<_T>, RangeValue<_T>, RangeReference<_T>, RangeSize<_T>, + RangeDifference<_T> > { private: - T p_beg; - T p_end; + _T __beg; + _T __end; public: - HalfRange(): p_beg(), p_end() {} - HalfRange(const HalfRange &range): p_beg(range.p_beg), - p_end(range.p_end) {} - HalfRange(HalfRange &&range): p_beg(move(range.p_beg)), - p_end(move(range.p_end)) {} - HalfRange(const T &beg, const T &end): p_beg(beg), p_end(end) {} - HalfRange(T &&beg, T &&end): p_beg(move(beg)), p_end(move(end)) {} + HalfRange(): __beg(), __end() {} + HalfRange(const HalfRange &__range): __beg(__range.__beg), + __end(__range.__end) {} + HalfRange(HalfRange &&__range): __beg(octa::move(__range.__beg)), + __end(octa::move(__range.__end)) {} + HalfRange(const _T &__beg, const _T &__end): __beg(__beg), + __end(__end) {} + HalfRange(_T &&__beg, _T &&__end): __beg(octa::move(__beg)), + __end(octa::move(__end)) {} - HalfRange &operator=(const HalfRange &range) { - p_beg = range.p_beg; - p_end = range.p_end; + HalfRange &operator=(const HalfRange &__range) { + __beg = __range.p_beg; + __end = __range.p_end; return *this; } - HalfRange &operator=(HalfRange &&range) { - p_beg = move(range.p_beg); - p_end = move(range.p_end); + HalfRange &operator=(HalfRange &&__range) { + __beg = octa::move(__range.p_beg); + __end = octa::move(__range.p_end); return *this; } - bool empty() const { return p_beg == p_end; } + bool empty() const { return __beg == __end; } bool pop_front() { if (empty()) return false; - return p_beg.next(); + return __beg.next(); } bool push_front() { - return p_beg.prev(); + return __beg.prev(); } bool pop_back() { if (empty()) return false; - return p_end.prev(); + return __end.prev(); } bool push_back() { - return p_end.next(); + return __end.next(); } - RangeReference front() const { return *p_beg; } - RangeReference back() const { return *(p_end - 1); } + RangeReference<_T> front() const { return *__beg; } + RangeReference<_T> back() const { return *(__end - 1); } - bool equals_front(const HalfRange &range) const { - return p_beg == range.p_beg; + bool equals_front(const HalfRange &__range) const { + return __beg == __range.__beg; } - bool equals_back(const HalfRange &range) const { - return p_end == range.p_end; + bool equals_back(const HalfRange &__range) const { + return __end == __range.__end; } - RangeDifference distance_front(const HalfRange &range) const { - return range.p_beg - p_beg; + RangeDifference<_T> distance_front(const HalfRange &__range) const { + return __range.__beg - __beg; } - RangeDifference distance_back(const HalfRange &range) const { - return range.p_end - p_end; + RangeDifference<_T> distance_back(const HalfRange &__range) const { + return __range.__end - __end; } - RangeSize size() const { return p_end - p_beg; } + RangeSize<_T> size() const { return __end - __beg; } - HalfRange slice(RangeSize start, RangeSize end) const { - return HalfRange(p_beg + start, p_beg + end); + HalfRange<_T> slice(RangeSize<_T> __start, RangeSize<_T> __end) const { + return HalfRange<_T>(__beg + __start, __beg + __end); } - RangeReference operator[](RangeSize idx) const { - return p_beg[idx]; + RangeReference<_T> operator[](RangeSize<_T> __idx) const { + return __beg[__idx]; } - void put(const RangeValue &v) { - p_beg.range().put(v); + void put(const RangeValue<_T> &__v) { + __beg.range().put(__v); } - void put(RangeValue &&v) { - p_beg.range().put(move(v)); + void put(RangeValue<_T> &&__v) { + __beg.range().put(octa::move(__v)); } }; - template - HalfRange> - make_half_range(const RangeHalf &a, const RangeHalf &b) { - return HalfRange>(a, b); + template + HalfRange> + make_half_range(const RangeHalf<_T> &__a, const RangeHalf<_T> &__b) { + return HalfRange>(__a, __b); } } diff --git a/octa/string.h b/octa/string.h index ccaff08..b6e56e9 100644 --- a/octa/string.h +++ b/octa/string.h @@ -14,298 +14,298 @@ #include "octa/vector.h" namespace octa { - using std::initializer_list; - static constexpr size_t npos = -1; - template + template class StringBase { - Vector p_buf; + octa::Vector<_T> __buf; - void terminate() { - if (p_buf.empty() || (p_buf.back() != '\0')) p_buf.push('\0'); + void __terminate() { + if (__buf.empty() || (__buf.back() != '\0')) __buf.push('\0'); } public: - typedef size_t SizeType; - typedef ptrdiff_t DiffType; - typedef T ValType; - typedef T &RefType; - typedef const T &ConstRefType; - typedef T *PtrType; - typedef const T *ConstPtrType; - typedef PointerRange< T> RangeType; - typedef PointerRange ConstRangeType; + typedef size_t SizeType; + typedef ptrdiff_t DiffType; + typedef _T ValType; + typedef _T &RefType; + typedef const _T &ConstRefType; + typedef _T *PtrType; + typedef const _T *ConstPtrType; + typedef PointerRange< _T> RangeType; + typedef PointerRange ConstRangeType; - StringBase(): p_buf(1, '\0') {} + StringBase(): __buf(1, '\0') {} - StringBase(const StringBase &s): p_buf(s.p_buf) {} - StringBase(StringBase &&s): p_buf(move(s.p_buf)) {} + StringBase(const StringBase &__s): __buf(__s.__buf) {} + StringBase(StringBase &&__s): __buf(octa::move(__s.__buf)) {} - StringBase(const StringBase &s, size_t pos, size_t len = npos): - p_buf(s.p_buf.each().slice(pos, - (len == npos) ? s.p_buf.size() : (pos + len))) { - terminate(); + StringBase(const StringBase &__s, size_t __pos, size_t __len = npos): + __buf(__s.__buf.each().slice(__pos, + (__len == npos) ? __s.__buf.size() : (__pos + __len))) { + __terminate(); } /* TODO: traits for utf-16/utf-32 string lengths, for now assume char */ - StringBase(const T *v): p_buf(PointerRange(v, strlen(v) + 1)) {} + StringBase(const _T *__v): __buf(ConstRangeType(__v, strlen(__v) + 1)) {} - template StringBase(R range): p_buf(range) { - terminate(); + template StringBase(_R __range): __buf(__range) { + __terminate(); } - void clear() { p_buf.clear(); } + void clear() { __buf.clear(); } - StringBase &operator=(const StringBase &v) { - p_buf.operator=(v); + StringBase<_T> &operator=(const StringBase &__v) { + __buf.operator=(__v); return *this; } - StringBase &operator=(StringBase &&v) { - p_buf.operator=(move(v)); + StringBase<_T> &operator=(StringBase &&__v) { + __buf.operator=(octa::move(__v)); return *this; } - StringBase &operator=(const T *v) { - p_buf = PointerRange(v, strlen(v) + 1); + StringBase<_T> &operator=(const _T *__v) { + __buf = ConstRangeType(__v, strlen(__v) + 1); return *this; } - void resize(size_t n, T v = T()) { - p_buf.pop(); - p_buf.resize(n, v); - terminate(); + void resize(size_t __n, _T __v = _T()) { + __buf.pop(); + __buf.resize(__n, __v); + __terminate(); } - void reserve(size_t n) { - p_buf.reserve(n + 1); + void reserve(size_t __n) { + __buf.reserve(__n + 1); } - T &operator[](size_t i) { return p_buf[i]; } - const T &operator[](size_t i) const { return p_buf[i]; } + _T &operator[](size_t __i) { return __buf[__i]; } + const _T &operator[](size_t __i) const { return __buf[__i]; } - T &at(size_t i) { return p_buf[i]; } - const T &at(size_t i) const { return p_buf[i]; } + _T &at(size_t __i) { return __buf[__i]; } + const _T &at(size_t __i) const { return __buf[__i]; } - T &front() { return p_buf[0]; } - const T &front() const { return p_buf[0]; }; + _T &front() { return __buf[0]; } + const _T &front() const { return __buf[0]; }; - T &back() { return p_buf[size() - 1]; } - const T &back() const { return p_buf[size() - 1]; } + _T &back() { return __buf[size() - 1]; } + const _T &back() const { return __buf[size() - 1]; } - T *data() { return p_buf.data(); } - const T *data() const { return p_buf.data(); } + _T *data() { return __buf.data(); } + const _T *data() const { return __buf.data(); } size_t size() const { - return p_buf.size() - 1; + return __buf.size() - 1; } size_t capacity() const { - return p_buf.capacity() - 1; + return __buf.capacity() - 1; } bool empty() const { return (size() == 0); } - void push(T v) { - p_buf.back() = v; - p_buf.push('\0'); + void push(_T __v) { + __buf.back() = __v; + __buf.push('\0'); } - StringBase &append(const StringBase &s) { - p_buf.pop(); - p_buf.insert_range(p_buf.size(), s.p_buf.each()); + StringBase<_T> &append(const StringBase &__s) { + __buf.pop(); + __buf.insert_range(__buf.size(), __s.__buf.each()); return *this; } - StringBase &append(const StringBase &s, size_t idx, size_t len) { - p_buf.pop(); - p_buf.insert_range(p_buf.size(), PointerRange(&s[idx], - (len == npos) ? (s.size() - idx) : len)); - terminate(); + StringBase<_T> &append(const StringBase &__s, size_t __idx, size_t __len) { + __buf.pop(); + __buf.insert_range(__buf.size(), octa::PointerRange<_T>(&__s[__idx], + (__len == npos) ? (__s.size() - __idx) : __len)); + __terminate(); return *this; } - StringBase &append(const T *s) { - p_buf.pop(); - p_buf.insert_range(p_buf.size(), PointerRange(s, - strlen(s) + 1)); + StringBase<_T> &append(const _T *__s) { + __buf.pop(); + __buf.insert_range(__buf.size(), ConstRangeType(__s, + strlen(__s) + 1)); return *this; } - StringBase &append(size_t n, T c) { - p_buf.pop(); - for (size_t i = 0; i < n; ++i) p_buf.push(c); - p_buf.push('\0'); + StringBase<_T> &append(size_t __n, _T __c) { + __buf.pop(); + for (size_t __i = 0; __i < __n; ++__i) __buf.push(__c); + __buf.push('\0'); return *this; } - template - StringBase &append_range(R range) { - p_buf.pop(); - p_buf.insert_range(p_buf.size(), range); - terminate(); + template + StringBase<_T> &append_range(_R __range) { + __buf.pop(); + __buf.insert_range(__buf.size(), __range); + __terminate(); return *this; } - StringBase &operator+=(const StringBase &s) { - return append(s); + StringBase<_T> &operator+=(const StringBase &__s) { + return append(__s); } - StringBase &operator+=(const T *s) { - return append(s); + StringBase<_T> &operator+=(const _T *__s) { + return append(__s); } - StringBase &operator+=(T c) { - p_buf.pop(); - p_buf.push(c); - p_buf.push('\0'); + StringBase<_T> &operator+=(_T __c) { + __buf.pop(); + __buf.push(__c); + __buf.push('\0'); return *this; } RangeType each() { - return PointerRange(p_buf.data(), size()); + return RangeType(__buf.data(), size()); } ConstRangeType each() const { - return PointerRange(p_buf.data(), size()); + return ConstRangeType(__buf.data(), size()); } - void swap(StringBase &v) { - p_buf.swap(v); + void swap(StringBase &__v) { + __buf.swap(__v); } }; typedef StringBase String; - template + template struct __OctaIsRangeTest { - template static char __octa_test(typename U::Category *); - template static int __octa_test(...); - static constexpr bool value = (sizeof(__octa_test(0)) == sizeof(char)); + template static char __test(typename _U::Category *); + template static int __test(...); + static constexpr bool value = (sizeof(__test<_T>(0)) == sizeof(char)); }; - template - String concat(const T &v, const String &sep, F func) { - String ret; - auto range = each(v); - if (range.empty()) return move(ret); + template + String concat(const _T &__v, const String &__sep, _F __func) { + String __ret; + auto __range = octa::each(__v); + if (__range.empty()) return octa::move(__ret); for (;;) { - ret += func(range.front()); - range.pop_front(); - if (range.empty()) break; - ret += sep; + __ret += __func(__range.front()); + __range.pop_front(); + if (__range.empty()) break; + __ret += __sep; } - return move(ret); + return octa::move(__ret); } - template - String concat(const T &v, const String &sep = " ") { - String ret; - auto range = each(v); - if (range.empty()) return move(ret); + template + String concat(const _T &__v, const String &__sep = " ") { + String __ret; + auto __range = octa::each(__v); + if (__range.empty()) return octa::move(__ret); for (;;) { - ret += range.front(); - range.pop_front(); - if (range.empty()) break; - ret += sep; + __ret += __range.front(); + __range.pop_front(); + if (__range.empty()) break; + __ret += __sep; } - return move(ret); + return octa::move(__ret); } - template - String concat(initializer_list v, const String &sep, F func) { - return concat(each(v), sep, func); + template + String concat(std::initializer_list<_T> __v, const String &__sep, _F __func) { + return concat(octa::each(__v), __sep, __func); } - template - String concat(initializer_list v, const String &sep = " ") { - return concat(each(v), sep); + template + String concat(std::initializer_list<_T> __v, const String &__sep = " ") { + return concat(octa::each(__v), __sep); } - template + template struct __OctaToStringTest { - template struct __OctaTest {}; - template static char __octa_test(__OctaTest *); - template static int __octa_test(...); - static constexpr bool value = (sizeof(__octa_test(0)) == sizeof(char)); + template struct __Test {}; + template static char __test(__Test<_U, &_U::to_string> *); + template static int __test(...); + static constexpr bool value = (sizeof(__test<_T>(0)) == sizeof(char)); }; - template struct ToString { - typedef T ArgType; + template struct ToString { + typedef _T ArgType; typedef String ResultType; - template - static String __octa_to_str(const U &v, - EnableIf<__OctaToStringTest::value, bool> = true + template + static String __octa_to_str(const _U &__v, + octa::EnableIf<__OctaToStringTest<_U>::value, bool> = true ) { - return v.to_string(); + return __v.to_string(); } - template - static String __octa_to_str(const U &v, - EnableIf::value && !IsScalar::value, - bool> = true + template + static String __octa_to_str(const _U &__v, + octa::EnableIf::value && + !octa::IsScalar<_U>::value, bool> = true ) { - String ret("{"); - ret += concat(each(v), ", ", ToString>()); - ret += "}"; - return move(ret); + __ret += "}"; + return octa::move(__ret); } - template - static String __octa_to_str(const U &v, - EnableIf::value && IsScalar::value, - bool> = true + template + static String __octa_to_str(const _U &__v, + octa::EnableIf::value && + octa::IsScalar<_U>::value, bool> = true ) { - return ToString()(v); + return ToString<_U>()(__v); } - String operator()(const T &v) { - return move(__octa_to_str>>(v)); + String operator()(const _T &__v) { + return octa::move(__octa_to_str + >>(__v)); } }; - template - void __octa_str_printf(Vector *s, const char *fmt, T v) { - char buf[256]; - int n = snprintf(buf, sizeof(buf), fmt, v); - s->clear(); - s->reserve(n + 1); - if (n >= (int)sizeof(buf)) - snprintf(s->data(), n + 1, fmt, v); - else if (n > 0) - memcpy(s->data(), buf, n + 1); + template + void __octa_str_printf(octa::Vector *__s, const char *__fmt, _T __v) { + char __buf[256]; + int __n = snprintf(__buf, sizeof(__buf), __fmt, __v); + __s->clear(); + __s->reserve(__n + 1); + if (__n >= (int)sizeof(__buf)) + snprintf(__s->data(), __n + 1, __fmt, __v); + else if (__n > 0) + memcpy(__s->data(), __buf, __n + 1); else { - n = 0; - *(s->data()) = '\0'; + __n = 0; + *(__s->data()) = '\0'; } - *(((size_t *)s) + 1) = n + 1; + *(((size_t *)__s) + 1) = __n + 1; } template<> struct ToString { typedef bool ArgType; typedef String ResultType; - String operator()(bool b) { - return b ? "true" : "false"; + String operator()(bool __b) { + return __b ? "true" : "false"; } }; template<> struct ToString { typedef char ArgType; typedef String ResultType; - String operator()(char c) { - String ret; - ret.push(c); - return move(ret); + String operator()(char __c) { + String __ret; + __ret.push(__c); + return octa::move(__ret); } }; -#define __OCTA_TOSTR_NUM(T, fmt) \ - template<> struct ToString { \ - typedef T ArgType; \ +#define __OCTA_TOSTR_NUM(_T, __fmt) \ + template<> struct ToString<_T> { \ + typedef _T ArgType; \ typedef String ResultType; \ - String operator()(T v) { \ - String ret; \ - __octa_str_printf((Vector *)&ret, fmt, v); \ - return move(ret); \ + String operator()(_T __v) { \ + String __ret; \ + __octa_str_printf((octa::Vector *)&__ret, __fmt, __v); \ + return octa::move(__ret); \ } \ }; @@ -322,45 +322,48 @@ namespace octa { #undef __OCTA_TOSTR_NUM - template struct ToString { - typedef T *ArgType; + template struct ToString<_T *> { + typedef _T *ArgType; typedef String ResultType; - String operator()(ArgType v) { - String ret; - __octa_str_printf((Vector *)&ret, "%p", v); - return move(ret); + String operator()(ArgType __v) { + String __ret; + __octa_str_printf((octa::Vector *)&__ret, "%p", __v); + return octa::move(__ret); } }; template<> struct ToString { typedef const String &ArgType; typedef String ResultType; - String operator()(ArgType s) { - return s; + String operator()(ArgType __s) { + return __s; } }; - template struct ToString> { - typedef const Pair &ArgType; + template struct ToString> { + typedef const octa::Pair<_T, _U> &ArgType; typedef String ResultType; - String operator()(ArgType v) { - String ret("{"); - ret += ToString>>()(v.first); - ret += ", "; - ret += ToString>>()(v.second); - ret += "}"; - return move(ret); + String operator()(ArgType __v) { + String __ret("{"); + __ret += ToString>>() + (__v.first); + __ret += ", "; + __ret += ToString>>() + (__v.second); + __ret += "}"; + return octa::move(__ret); } }; - template - String to_string(const T &v) { - return move(ToString>>()(v)); + template + String to_string(const _T &__v) { + return octa::move(ToString>> + ()(__v)); } - template - String to_string(initializer_list init) { - return move(ToString>()(init)); + template + String to_string(std::initializer_list<_T> __init) { + return octa::move(ToString>()(__init)); } } diff --git a/octa/type_traits.h b/octa/type_traits.h index 487656b..7a1dc0f 100644 --- a/octa/type_traits.h +++ b/octa/type_traits.h @@ -24,35 +24,35 @@ namespace octa { template struct __OctaCommonType; - template - using RemoveCv = typename __OctaRemoveCv::Type; + template + using RemoveCv = typename __OctaRemoveCv<_T>::Type; - template - using AddLvalueReference = typename __OctaAddLr::Type; + template + using AddLvalueReference = typename __OctaAddLr<_T>::Type; - template - using AddRvalueReference = typename __OctaAddRr::Type; + template + using AddRvalueReference = typename __OctaAddRr<_T>::Type; - template - using AddConst = typename __OctaAddConst::Type; + template + using AddConst = typename __OctaAddConst<_T>::Type; - template - using RemoveReference = typename __OctaRemoveReference::Type; + template + using RemoveReference = typename __OctaRemoveReference<_T>::Type; - template - using RemoveAllExtents = typename __OctaRemoveAllExtents::Type; + template + using RemoveAllExtents = typename __OctaRemoveAllExtents<_T>::Type; /* declval also defined here to avoid including utility.h */ - template AddRvalueReference __octa_declval(); + template AddRvalueReference<_T> __octa_declval(); /* integral constant */ - template + template struct IntegralConstant { - static constexpr T value = val; + static constexpr _T value = __val; - typedef T ValType; - typedef IntegralConstant Type; + typedef _T ValType; + typedef IntegralConstant<_T, __val> Type; constexpr operator ValType() const { return value; } constexpr ValType operator()() const { return value; } @@ -61,27 +61,27 @@ namespace octa { typedef IntegralConstant True; typedef IntegralConstant False; - template constexpr T IntegralConstant::value; + template constexpr _T IntegralConstant<_T, val>::value; /* is void */ - template struct __OctaIsVoid : False {}; - template< > struct __OctaIsVoid: True {}; + template struct __OctaIsVoid : False {}; + template< > struct __OctaIsVoid: True {}; - template - struct IsVoid: __OctaIsVoid> {}; + template + struct IsVoid: __OctaIsVoid> {}; /* is null pointer */ template struct __OctaIsNullPointer : False {}; template< > struct __OctaIsNullPointer: True {}; - template struct IsNullPointer: - __OctaIsNullPointer> {}; + template struct IsNullPointer: + __OctaIsNullPointer> {}; /* is integer */ - template struct __OctaIsIntegral: False {}; + template struct __OctaIsIntegral: False {}; template<> struct __OctaIsIntegral: True {}; template<> struct __OctaIsIntegral: True {}; @@ -100,94 +100,94 @@ namespace octa { template<> struct __OctaIsIntegral: True {}; template<> struct __OctaIsIntegral< wchar_t>: True {}; - template - struct IsIntegral: __OctaIsIntegral> {}; + template + struct IsIntegral: __OctaIsIntegral> {}; /* is floating point */ - template struct __OctaIsFloatingPoint: False {}; + template struct __OctaIsFloatingPoint: False {}; template<> struct __OctaIsFloatingPoint: True {}; template<> struct __OctaIsFloatingPoint: True {}; template<> struct __OctaIsFloatingPoint: True {}; - template - struct IsFloatingPoint: __OctaIsFloatingPoint> {}; + template + struct IsFloatingPoint: __OctaIsFloatingPoint> {}; /* is array */ - template struct IsArray : False {}; - template struct IsArray: True {}; - template struct IsArray: True {}; + template struct IsArray : False {}; + template struct IsArray<_T[] >: True {}; + template struct IsArray<_T[_N]>: True {}; /* is pointer */ - template struct __OctaIsPointer : False {}; - template struct __OctaIsPointer: True {}; + template struct __OctaIsPointer : False {}; + template struct __OctaIsPointer<_T *>: True {}; - template - struct IsPointer: __OctaIsPointer> {}; + template + struct IsPointer: __OctaIsPointer> {}; /* is lvalue reference */ - template struct IsLvalueReference : False {}; - template struct IsLvalueReference: True {}; + template struct IsLvalueReference : False {}; + template struct IsLvalueReference<_T &>: True {}; /* is rvalue reference */ - template struct IsRvalueReference : False {}; - template struct IsRvalueReference: True {}; + template struct IsRvalueReference : False {}; + template struct IsRvalueReference<_T &&>: True {}; /* is enum */ - template struct IsEnum: IntegralConstant {}; + template struct IsEnum: IntegralConstant {}; /* is union */ - template struct IsUnion: IntegralConstant {}; + template struct IsUnion: IntegralConstant {}; /* is class */ - template struct IsClass: IntegralConstant {}; + template struct IsClass: IntegralConstant {}; /* is function */ struct __OctaFunctionTestDummy {}; - template char __octa_function_test(T *); - template char __octa_function_test(__OctaFunctionTestDummy); - template int __octa_function_test(...); + template char __octa_function_test(_T *); + template char __octa_function_test(__OctaFunctionTestDummy); + template int __octa_function_test(...); - template T &__octa_function_source(int); - template __OctaFunctionTestDummy __octa_function_source(...); + template _T &__octa_function_source(int); + template __OctaFunctionTestDummy __octa_function_source(...); - template::value || IsUnion::value - || IsVoid::value || IsReference::value - || IsNullPointer::value + template::value || IsUnion<_T>::value + || IsVoid<_T>::value || IsReference<_T>::value + || IsNullPointer<_T>::value > struct __OctaIsFunction: IntegralConstant(__octa_function_source(0))) == 1 + sizeof(__octa_function_test<_T>(__octa_function_source<_T>(0))) == 1 > {}; - template struct __OctaIsFunction: False {}; + template struct __OctaIsFunction<_T, true>: False {}; - template struct IsFunction: __OctaIsFunction {}; + template struct IsFunction: __OctaIsFunction<_T> {}; /* is arithmetic */ - template struct IsArithmetic: IntegralConstant::value || IsFloatingPoint::value) + template struct IsArithmetic: IntegralConstant::value || IsFloatingPoint<_T>::value) > {}; /* is fundamental */ - template struct IsFundamental: IntegralConstant::value || IsVoid::value || IsNullPointer::value) + template struct IsFundamental: IntegralConstant::value || IsVoid<_T>::value || IsNullPointer<_T>::value) > {}; /* is compound */ - template struct IsCompound: IntegralConstant::value + template struct IsCompound: IntegralConstant::value > {}; /* is pointer to member */ @@ -195,547 +195,549 @@ namespace octa { template struct __OctaIsMemberPointer: False {}; - template - struct __OctaIsMemberPointer: True {}; + template + struct __OctaIsMemberPointer<_T _U::*>: True {}; - template - struct IsMemberPointer: __OctaIsMemberPointer> {}; + template + struct IsMemberPointer: __OctaIsMemberPointer> {}; /* is pointer to member object */ template struct __OctaIsMemberObjectPointer: False {}; - template - struct __OctaIsMemberObjectPointer: IntegralConstant::value + template + struct __OctaIsMemberObjectPointer<_T _U::*>: IntegralConstant::value > {}; - template struct IsMemberObjectPointer: - __OctaIsMemberObjectPointer> {}; + template struct IsMemberObjectPointer: + __OctaIsMemberObjectPointer> {}; /* is pointer to member function */ template struct __OctaIsMemberFunctionPointer: False {}; - template - struct __OctaIsMemberFunctionPointer: IntegralConstant::value + template + struct __OctaIsMemberFunctionPointer<_T _U::*>: IntegralConstant::value > {}; - template struct IsMemberFunctionPointer: - __OctaIsMemberFunctionPointer> {}; + template struct IsMemberFunctionPointer: + __OctaIsMemberFunctionPointer> {}; /* is reference */ - template struct IsReference: IntegralConstant::value || IsRvalueReference::value) + template struct IsReference: IntegralConstant::value || IsRvalueReference<_T>::value) > {}; /* is object */ - template struct IsObject: IntegralConstant::value && !IsVoid::value && !IsReference::value) + template struct IsObject: IntegralConstant::value && !IsVoid<_T>::value && !IsReference<_T>::value) > {}; /* is scalar */ - template struct IsScalar: IntegralConstant::value || IsPointer::value || IsEnum::value - || IsNullPointer ::value || IsArithmetic::value) + template struct IsScalar: IntegralConstant::value || IsPointer<_T>::value || IsEnum<_T>::value + || IsNullPointer <_T>::value || IsArithmetic<_T>::value) > {}; /* is abstract */ - template - struct IsAbstract: IntegralConstant {}; + template + struct IsAbstract: IntegralConstant {}; /* is const */ - template struct IsConst : False {}; - template struct IsConst: True {}; + template struct IsConst : False {}; + template struct IsConst: True {}; /* is volatile */ - template struct IsVolatile : False {}; - template struct IsVolatile: True {}; + template struct IsVolatile : False {}; + template struct IsVolatile: True {}; /* is empty */ - template - struct IsEmpty: IntegralConstant {}; + template + struct IsEmpty: IntegralConstant {}; /* is POD */ - template struct IsPod: IntegralConstant {}; + template struct IsPod: IntegralConstant {}; /* is polymorphic */ - template - struct IsPolymorphic: IntegralConstant {}; + template + struct IsPolymorphic: IntegralConstant {}; /* is signed */ - template - struct IsSigned: IntegralConstant {}; + template + struct IsSigned: IntegralConstant {}; /* is unsigned */ - template - struct IsUnsigned: IntegralConstant {}; + template + struct IsUnsigned: IntegralConstant {}; /* is standard layout */ - template - struct IsStandardLayout: IntegralConstant {}; + template + struct IsStandardLayout: IntegralConstant {}; /* is literal type */ - template - struct IsLiteralType: IntegralConstant {}; + template + struct IsLiteralType: IntegralConstant {}; /* is trivially copyable */ - template + template struct IsTriviallyCopyable: IntegralConstant>::value + IsScalar>::value > {}; /* is trivial */ - template - struct IsTrivial: IntegralConstant {}; + template + struct IsTrivial: IntegralConstant {}; /* has virtual destructor */ - template + template struct HasVirtualDestructor: IntegralConstant {}; /* is constructible */ #define __OCTA_MOVE(v) static_cast &&>(v) - template struct __OctaSelect2nd { typedef T Type; }; + template struct __OctaSelect2nd { typedef _T Type; }; struct __OctaAny { __OctaAny(...); }; - template typename __OctaSelect2nd< - decltype(__OCTA_MOVE(T(__octa_declval()...))), True - >::Type __octa_is_ctible_test(T &&, A &&...); + template typename __OctaSelect2nd< + decltype(__OCTA_MOVE(_T(__octa_declval<_A>()...))), True + >::Type __octa_is_ctible_test(_T &&, _A &&...); //#undef __OCTA_MOVE - template False __octa_is_ctible_test(__OctaAny, A &&...); + template False __octa_is_ctible_test(__OctaAny, _A &&...); - template + template struct __OctaCtibleCore: __OctaCommonType< - decltype(__octa_is_ctible_test(__octa_declval(), - __octa_declval()...)) + decltype(__octa_is_ctible_test(__octa_declval<_T>(), + __octa_declval<_A>()...)) >::Type {}; /* function types are not constructible */ - template - struct __OctaCtibleCore: False {}; + template + struct __OctaCtibleCore: False {}; /* scalars are default constructible, refs are not */ - template - struct __OctaCtibleCore: IsScalar {}; + template + struct __OctaCtibleCore: IsScalar<_T> {}; /* scalars and references are constructible from one arg if * implicitly convertible to scalar or reference */ - template + template struct __OctaCtibleRef { - static True test(T); - static False test(...); + static True __test(_T); + static False __test(...); }; - template - struct __OctaCtibleCore: __OctaCommonType< - decltype(__OctaCtibleRef::test(__octa_declval())) + template + struct __OctaCtibleCore: __OctaCommonType< + decltype(__OctaCtibleRef<_T>::__test(__octa_declval<_U>())) >::Type {}; /* scalars and references are not constructible from multiple args */ - template - struct __OctaCtibleCore: False {}; + template + struct __OctaCtibleCore: False {}; /* treat scalars and refs separately */ - template + template struct __OctaCtibleVoidCheck: __OctaCtibleCore< - (IsScalar::value || IsReference::value), T, A... + (IsScalar<_T>::value || IsReference<_T>::value), _T, _A... > {}; /* if any of T or A is void, IsConstructible should be false */ - template - struct __OctaCtibleVoidCheck: False {}; + template + struct __OctaCtibleVoidCheck: False {}; - template struct __OctaCtibleContainsVoid; + template struct __OctaCtibleContainsVoid; template<> struct __OctaCtibleContainsVoid<>: False {}; - template - struct __OctaCtibleContainsVoid { - static constexpr bool value = IsVoid::value - || __OctaCtibleContainsVoid::value; + template + struct __OctaCtibleContainsVoid<_T, _A...> { + static constexpr bool value = IsVoid<_T>::value + || __OctaCtibleContainsVoid<_A...>::value; }; /* entry point */ - template + template struct __OctaCtible: __OctaCtibleVoidCheck< - __OctaCtibleContainsVoid::value || IsAbstract::value, - T, A... + __OctaCtibleContainsVoid<_T, _A...>::value || IsAbstract<_T>::value, + _T, _A... > {}; /* array types are default constructible if their element type is */ - template - struct __OctaCtibleCore: __OctaCtible> {}; + template + struct __OctaCtibleCore: __OctaCtible> {}; /* otherwise array types are not constructible by this syntax */ - template - struct __OctaCtibleCore: False {}; + template + struct __OctaCtibleCore: False {}; /* incomplete array types are not constructible */ - template - struct __OctaCtibleCore: False {}; + template + struct __OctaCtibleCore: False {}; - template - struct IsConstructible: __OctaCtible {}; + template + struct IsConstructible: __OctaCtible<_T, _A...> {}; /* is default constructible */ - template struct IsDefaultConstructible: IsConstructible {}; + template struct IsDefaultConstructible: IsConstructible<_T> {}; /* is copy constructible */ - template struct IsCopyConstructible: IsConstructible> + template struct IsCopyConstructible: IsConstructible<_T, + AddLvalueReference> > {}; /* is move constructible */ - template struct IsMoveConstructible: IsConstructible + template struct IsMoveConstructible: IsConstructible<_T, + AddRvalueReference<_T> > {}; /* is assignable */ - template typename __OctaSelect2nd< - decltype((__octa_declval() = __octa_declval())), True - >::Type __octa_assign_test(T &&, U &&); + template typename __OctaSelect2nd< + decltype((__octa_declval<_T>() = __octa_declval<_U>())), True + >::Type __octa_assign_test(_T &&, _U &&); - template False __octa_assign_test(__OctaAny, T &&); + template False __octa_assign_test(__OctaAny, _T &&); - template::value || IsVoid::value> - struct __OctaIsAssignable: __OctaCommonType< - decltype(__octa_assign_test(__octa_declval(), __octa_declval())) + template::value || + IsVoid<_U>::value + > struct __OctaIsAssignable: __OctaCommonType< + decltype(__octa_assign_test(__octa_declval<_T>(), __octa_declval<_U>())) >::Type {}; - template - struct __OctaIsAssignable: False {}; + template + struct __OctaIsAssignable<_T, _U, true>: False {}; - template - struct IsAssignable: __OctaIsAssignable {}; + template + struct IsAssignable: __OctaIsAssignable<_T, _U> {}; /* is copy assignable */ - template struct IsCopyAssignable: IsAssignable< - AddLvalueReference, - AddLvalueReference> + template struct IsCopyAssignable: IsAssignable< + AddLvalueReference<_T>, + AddLvalueReference> > {}; /* is move assignable */ - template struct IsMoveAssignable: IsAssignable< - AddLvalueReference, - const AddRvalueReference + template struct IsMoveAssignable: IsAssignable< + AddLvalueReference<_T>, + const AddRvalueReference<_T> > {}; /* is destructible */ template struct __OctaIsDtibleApply { typedef int Type; }; - template struct IsDestructorWellformed { - template static char test(typename __OctaIsDtibleApply< - decltype(__octa_declval().~TT()) + template struct IsDestructorWellformed { + template static char __test(typename __OctaIsDtibleApply< + decltype(__octa_declval<_TT &>().~_TT()) >::Type); - template static int test(...); + template static int __test(...); - static constexpr bool value = (sizeof(test(12)) == sizeof(char)); + static constexpr bool value = (sizeof(__test<_T>(12)) == sizeof(char)); }; template struct __OctaDtibleImpl; - template - struct __OctaDtibleImpl: IntegralConstant>::value + template + struct __OctaDtibleImpl<_T, false>: IntegralConstant>::value > {}; - template - struct __OctaDtibleImpl: True {}; + template + struct __OctaDtibleImpl<_T, true>: True {}; - template struct __OctaDtibleFalse; + template struct __OctaDtibleFalse; - template struct __OctaDtibleFalse - : __OctaDtibleImpl::value> {}; + template struct __OctaDtibleFalse<_T, false> + : __OctaDtibleImpl<_T, IsReference<_T>::value> {}; - template struct __OctaDtibleFalse: False {}; + template struct __OctaDtibleFalse<_T, true>: False {}; - template - struct IsDestructible: __OctaDtibleFalse::value> {}; + template + struct IsDestructible: __OctaDtibleFalse<_T, IsFunction<_T>::value> {}; - template struct IsDestructible: False {}; - template< > struct IsDestructible: False {}; + template struct IsDestructible<_T[]>: False {}; + template< > struct IsDestructible: False {}; /* is trivially constructible */ - template + template struct IsTriviallyConstructible: False {}; - template - struct IsTriviallyConstructible: IntegralConstant + struct IsTriviallyConstructible<_T>: IntegralConstant {}; - template - struct IsTriviallyConstructible: IntegralConstant + struct IsTriviallyConstructible<_T, _T &>: IntegralConstant {}; - template - struct IsTriviallyConstructible: IntegralConstant + struct IsTriviallyConstructible<_T, const _T &>: IntegralConstant {}; - template - struct IsTriviallyConstructible: IntegralConstant + struct IsTriviallyConstructible<_T, _T &&>: IntegralConstant {}; /* is trivially default constructible */ - template - struct IsTriviallyDefaultConstructible: IsTriviallyConstructible {}; + template + struct IsTriviallyDefaultConstructible: IsTriviallyConstructible<_T> {}; /* is trivially copy constructible */ - template - struct IsTriviallyCopyConstructible: IsTriviallyConstructible + template + struct IsTriviallyCopyConstructible: IsTriviallyConstructible<_T, + AddLvalueReference > {}; /* is trivially move constructible */ - template - struct IsTriviallyMoveConstructible: IsTriviallyConstructible + template + struct IsTriviallyMoveConstructible: IsTriviallyConstructible<_T, + AddRvalueReference<_T> > {}; /* is trivially assignable */ - template + template struct IsTriviallyAssignable: False {}; - template - struct IsTriviallyAssignable: IntegralConstant + struct IsTriviallyAssignable<_T>: IntegralConstant {}; - template - struct IsTriviallyAssignable: IntegralConstant + struct IsTriviallyAssignable<_T, _T &>: IntegralConstant {}; - template - struct IsTriviallyAssignable: IntegralConstant + struct IsTriviallyAssignable<_T, const _T &>: IntegralConstant {}; - template - struct IsTriviallyAssignable: IntegralConstant + struct IsTriviallyAssignable<_T, _T &&>: IntegralConstant {}; /* is trivially copy assignable */ - template - struct IsTriviallyCopyAssignable: IsTriviallyAssignable + template + struct IsTriviallyCopyAssignable: IsTriviallyAssignable<_T, + AddLvalueReference > {}; /* is trivially move assignable */ - template - struct IsTriviallyMoveAssignable: IsTriviallyAssignable + template + struct IsTriviallyMoveAssignable: IsTriviallyAssignable<_T, + AddRvalueReference<_T> > {}; /* is trivially destructible */ - template + template struct IsTriviallyDestructible: IntegralConstant {}; /* is base of */ - template - struct IsBaseOf: IntegralConstant {}; + template + struct IsBaseOf: IntegralConstant {}; /* is convertible */ - template::value - || IsFunction::value || IsArray::value + template::value + || IsFunction<_T>::value || IsArray<_T>::value > struct __OctaIsConvertible { - typedef typename IsVoid::Type Type; + typedef typename IsVoid<_T>::Type Type; }; - template struct __OctaIsConvertible { - template static void test_f(TT); + template + struct __OctaIsConvertible<_F, _T, false> { + template static void __test_f(_TT); - template(__octa_declval())) - > static True test(int); + template(__octa_declval<_FF>())) + > static True __test(int); - template static False test(...); + template static False __test(...); - typedef decltype(test(0)) Type; + typedef decltype(__test<_F, _T>(0)) Type; }; - template - struct IsConvertible: __OctaIsConvertible::Type {}; + template + struct IsConvertible: __OctaIsConvertible<_F, _T>::Type {}; /* type equality */ - template struct IsSame : False {}; - template struct IsSame: True {}; + template struct IsSame : False {}; + template struct IsSame<_T, _T>: True {}; /* extent */ - template + template struct Extent: IntegralConstant {}; - template - struct Extent: IntegralConstant {}; + template + struct Extent<_T[], 0>: IntegralConstant {}; - template - struct Extent: IntegralConstant::value> {}; + template + struct Extent<_T[], _I>: IntegralConstant::value> {}; - template - struct Extent: IntegralConstant {}; + template + struct Extent<_T[_N], 0>: IntegralConstant {}; - template - struct Extent: IntegralConstant::value> {}; + template + struct Extent<_T[_N], _I>: IntegralConstant::value> {}; /* rank */ - template struct Rank: IntegralConstant {}; + template struct Rank: IntegralConstant {}; - template - struct Rank: IntegralConstant::value + 1> {}; + template + struct Rank<_T[]>: IntegralConstant::value + 1> {}; - template - struct Rank: IntegralConstant::value + 1> {}; + template + struct Rank<_T[_N]>: IntegralConstant::value + 1> {}; /* remove const, volatile, cv */ - template - struct __OctaRemoveConst { typedef T Type; }; - template - struct __OctaRemoveConst { typedef T Type; }; + template + struct __OctaRemoveConst { typedef _T Type; }; + template + struct __OctaRemoveConst { typedef _T Type; }; - template - struct __OctaRemoveVolatile { typedef T Type; }; - template - struct __OctaRemoveVolatile { typedef T Type; }; + template + struct __OctaRemoveVolatile { typedef _T Type; }; + template + struct __OctaRemoveVolatile { typedef _T Type; }; - template - using RemoveConst = typename __OctaRemoveConst::Type; - template - using RemoveVolatile = typename __OctaRemoveVolatile::Type; + template + using RemoveConst = typename __OctaRemoveConst<_T>::Type; + template + using RemoveVolatile = typename __OctaRemoveVolatile<_T>::Type; - template + template struct __OctaRemoveCv { - typedef RemoveVolatile> Type; + typedef RemoveVolatile> Type; }; /* add const, volatile, cv */ - template::value - || IsFunction::value || IsConst::value> - struct __OctaAddConstBase { typedef T Type; }; + template::value + || IsFunction<_T>::value || IsConst<_T>::value> + struct __OctaAddConstBase { typedef _T Type; }; - template struct __OctaAddConstBase { - typedef const T Type; + template struct __OctaAddConstBase<_T, false> { + typedef const _T Type; }; - template struct __OctaAddConst { - typedef typename __OctaAddConstBase::Type Type; + template struct __OctaAddConst { + typedef typename __OctaAddConstBase<_T>::Type Type; }; - template::value - || IsFunction::value || IsVolatile::value> - struct __OctaAddVolatileBase { typedef T Type; }; + template::value + || IsFunction<_T>::value || IsVolatile<_T>::value> + struct __OctaAddVolatileBase { typedef _T Type; }; - template struct __OctaAddVolatileBase { - typedef volatile T Type; + template struct __OctaAddVolatileBase<_T, false> { + typedef volatile _T Type; }; - template struct __OctaAddVolatile { - typedef typename __OctaAddVolatileBase::Type Type; + template struct __OctaAddVolatile { + typedef typename __OctaAddVolatileBase<_T>::Type Type; }; - template - using AddVolatile = typename __OctaAddVolatile::Type; + template + using AddVolatile = typename __OctaAddVolatile<_T>::Type; - template + template struct __OctaAddCv { - typedef AddConst> Type; + typedef AddConst> Type; }; - template - using AddCv = typename __OctaAddCv::Type; + template + using AddCv = typename __OctaAddCv<_T>::Type; /* remove reference */ - template - struct __OctaRemoveReference { typedef T Type; }; - template - struct __OctaRemoveReference { typedef T Type; }; - template - struct __OctaRemoveReference { typedef T Type; }; + template + struct __OctaRemoveReference { typedef _T Type; }; + template + struct __OctaRemoveReference<_T &> { typedef _T Type; }; + template + struct __OctaRemoveReference<_T &&> { typedef _T Type; }; /* remove pointer */ - template - struct __OctaRemovePointer { typedef T Type; }; - template - struct __OctaRemovePointer { typedef T Type; }; - template - struct __OctaRemovePointer { typedef T Type; }; - template - struct __OctaRemovePointer { typedef T Type; }; - template - struct __OctaRemovePointer { typedef T Type; }; + template + struct __OctaRemovePointer { typedef _T Type; }; + template + struct __OctaRemovePointer<_T * > { typedef _T Type; }; + template + struct __OctaRemovePointer<_T * const > { typedef _T Type; }; + template + struct __OctaRemovePointer<_T * volatile > { typedef _T Type; }; + template + struct __OctaRemovePointer<_T * const volatile> { typedef _T Type; }; - template - using RemovePointer = typename __OctaRemovePointer::Type; + template + using RemovePointer = typename __OctaRemovePointer<_T>::Type; /* add pointer */ - template struct __OctaAddPointer { - typedef RemoveReference *Type; + template struct __OctaAddPointer { + typedef RemoveReference<_T> *Type; }; - template - using AddPointer = typename __OctaAddPointer::Type; + template + using AddPointer = typename __OctaAddPointer<_T>::Type; /* add lvalue reference */ - template struct __OctaAddLr { typedef T &Type; }; - template struct __OctaAddLr { typedef T &Type; }; - template struct __OctaAddLr { typedef T &Type; }; + template struct __OctaAddLr { typedef _T &Type; }; + template struct __OctaAddLr<_T &> { typedef _T &Type; }; + template struct __OctaAddLr<_T &&> { typedef _T &Type; }; template<> struct __OctaAddLr { typedef void Type; }; @@ -751,9 +753,9 @@ namespace octa { /* add rvalue reference */ - template struct __OctaAddRr { typedef T &&Type; }; - template struct __OctaAddRr { typedef T &&Type; }; - template struct __OctaAddRr { typedef T &&Type; }; + template struct __OctaAddRr { typedef _T &&Type; }; + template struct __OctaAddRr<_T &> { typedef _T &&Type; }; + template struct __OctaAddRr<_T &&> { typedef _T &&Type; }; template<> struct __OctaAddRr { typedef void Type; }; @@ -769,26 +771,26 @@ namespace octa { /* remove extent */ - template - struct __OctaRemoveExtent { typedef T Type; }; - template - struct __OctaRemoveExtent { typedef T Type; }; - template - struct __OctaRemoveExtent { typedef T Type; }; + template + struct __OctaRemoveExtent { typedef _T Type; }; + template + struct __OctaRemoveExtent<_T[ ] > { typedef _T Type; }; + template + struct __OctaRemoveExtent<_T[_N]> { typedef _T Type; }; - template - using RemoveExtent = typename __OctaRemoveExtent::Type; + template + using RemoveExtent = typename __OctaRemoveExtent<_T>::Type; /* remove all extents */ - template struct __OctaRemoveAllExtents { typedef T Type; }; + template struct __OctaRemoveAllExtents { typedef _T Type; }; - template struct __OctaRemoveAllExtents { - typedef RemoveAllExtents Type; + template struct __OctaRemoveAllExtents<_T[]> { + typedef RemoveAllExtents<_T> Type; }; - template struct __OctaRemoveAllExtents { - typedef RemoveAllExtents Type; + template struct __OctaRemoveAllExtents<_T[_N]> { + typedef RemoveAllExtents<_T> Type; }; /* make (un)signed @@ -797,9 +799,9 @@ namespace octa { * shamelessly copied from graphitemaster @ neothyne */ - template struct __OctaTl { - typedef T first; - typedef U rest; + template struct __OctaTl { + typedef _T __first; + typedef _U __rest; }; /* not a type */ @@ -814,78 +816,78 @@ namespace octa { __OctaTl>>>> stypes; + __OctaTl>>>> __octa_stypes; typedef __OctaTl>>>> utypes; + __OctaTl>>>> __octa_utypes; - template + template struct __OctaTypeFindFirst; - template - struct __OctaTypeFindFirst<__OctaTl, N, true> { - typedef T Type; + template + struct __OctaTypeFindFirst<__OctaTl<_T, _U>, _N, true> { + typedef _T Type; }; - template - struct __OctaTypeFindFirst<__OctaTl, N, false> { - typedef typename __OctaTypeFindFirst::Type Type; + template + struct __OctaTypeFindFirst<__OctaTl<_T, _U>, _N, false> { + typedef typename __OctaTypeFindFirst<_U, _N>::Type Type; }; - template>::value, - bool = IsVolatile>::value + template>::value, + bool = IsVolatile>::value > struct __OctaApplyCv { - typedef U Type; + typedef _U Type; }; - template - struct __OctaApplyCv { /* const */ - typedef const U Type; + template + struct __OctaApplyCv<_T, _U, true, false> { /* const */ + typedef const _U Type; }; - template - struct __OctaApplyCv { /* volatile */ - typedef volatile U Type; + template + struct __OctaApplyCv<_T, _U, false, true> { /* volatile */ + typedef volatile _U Type; }; - template - struct __OctaApplyCv { /* const volatile */ - typedef const volatile U Type; + template + struct __OctaApplyCv<_T, _U, true, true> { /* const volatile */ + typedef const volatile _U Type; }; - template - struct __OctaApplyCv { /* const */ - typedef const U &Type; + template + struct __OctaApplyCv<_T &, _U, true, false> { /* const */ + typedef const _U &Type; }; - template - struct __OctaApplyCv { /* volatile */ - typedef volatile U &Type; + template + struct __OctaApplyCv<_T &, _U, false, true> { /* volatile */ + typedef volatile _U &Type; }; - template - struct __OctaApplyCv { /* const volatile */ - typedef const volatile U &Type; + template + struct __OctaApplyCv<_T &, _U, true, true> { /* const volatile */ + typedef const volatile _U &Type; }; - template::value || IsEnum::value> + template::value || IsEnum<_T>::value> struct __OctaMakeSigned {}; - template::value || IsEnum::value> + template::value || IsEnum<_T>::value> struct __OctaMakeUnsigned {}; - template - struct __OctaMakeSigned { - typedef typename __OctaTypeFindFirst::Type Type; + template + struct __OctaMakeSigned<_T, true> { + typedef typename __OctaTypeFindFirst<__octa_stypes, sizeof(_T)>::Type Type; }; - template - struct __OctaMakeUnsigned { - typedef typename __OctaTypeFindFirst::Type Type; + template + struct __OctaMakeUnsigned<_T, true> { + typedef typename __OctaTypeFindFirst<__octa_utypes, sizeof(_T)>::Type Type; }; template<> struct __OctaMakeSigned {}; @@ -912,188 +914,190 @@ namespace octa { template<> struct __OctaMakeUnsigned { typedef ullong Type; }; template<> struct __OctaMakeUnsigned { typedef ullong Type; }; - template struct __OctaMakeSignedBase { - typedef typename __OctaApplyCv>::Type + template struct __OctaMakeSignedBase { + typedef typename __OctaApplyCv<_T, + typename __OctaMakeSigned>::Type >::Type Type; }; - template struct __OctaMakeUnsignedBase { - typedef typename __OctaApplyCv>::Type + template struct __OctaMakeUnsignedBase { + typedef typename __OctaApplyCv<_T, + typename __OctaMakeUnsigned>::Type >::Type Type; }; - template - using MakeSigned = typename __OctaMakeSignedBase::Type; - template - using MakeUnsigned = typename __OctaMakeUnsignedBase::Type; + template + using MakeSigned = typename __OctaMakeSignedBase<_T>::Type; + template + using MakeUnsigned = typename __OctaMakeUnsignedBase<_T>::Type; /* conditional */ - template + template struct __OctaConditional { - typedef T Type; + typedef _T Type; }; - template - struct __OctaConditional { - typedef U Type; + template + struct __OctaConditional { + typedef _U Type; }; - template - using Conditional = typename __OctaConditional::Type; + template + using Conditional = typename __OctaConditional<_cond, _T, _U>::Type; /* result of call at compile time */ -#define __OCTA_FWD(T, v) static_cast(v) - template - inline auto __octa_rof_invoke(F &&f, A &&...args) -> - decltype(__OCTA_FWD(F, f)(__OCTA_FWD(A, args)...)) { - return __OCTA_FWD(F, f)(__OCTA_FWD(A, args)...); +#define __OCTA_FWD(_T, _v) static_cast<_T &&>(_v) + template + inline auto __octa_rof_invoke(_F &&__f, _A &&...__args) -> + decltype(__OCTA_FWD(_F, __f)(__OCTA_FWD(_A, __args)...)) { + return __OCTA_FWD(_F, __f)(__OCTA_FWD(_A, __args)...); } - template - inline auto __octa_rof_invoke(T B::*pmd, D &&ref) -> - decltype(__OCTA_FWD(D, ref).*pmd) { - return __OCTA_FWD(D, ref).*pmd; + template + inline auto __octa_rof_invoke(_T _B::*__pmd, _D &&__ref) -> + decltype(__OCTA_FWD(_D, __ref).*__pmd) { + return __OCTA_FWD(_D, __ref).*__pmd; } - template - inline auto __octa_rof_invoke(PMD &&pmd, P &&ptr) -> - decltype((*__OCTA_FWD(P, ptr)).*__OCTA_FWD(PMD, pmd)) { - return (*__OCTA_FWD(P, ptr)).*__OCTA_FWD(PMD, pmd); + template + inline auto __octa_rof_invoke(_PMD &&__pmd, _P &&__ptr) -> + decltype((*__OCTA_FWD(_P, __ptr)).*__OCTA_FWD(_PMD, __pmd)) { + return (*__OCTA_FWD(_P, __ptr)).*__OCTA_FWD(_PMD, __pmd); } - template - inline auto __octa_rof_invoke(T B::*pmf, D &&ref, A &&...args) -> - decltype((__OCTA_FWD(D, ref).*pmf)(__OCTA_FWD(A, args)...)) { - return (__OCTA_FWD(D, ref).*pmf)(__OCTA_FWD(A, args)...); + template + inline auto __octa_rof_invoke(_T _B::*__pmf, _D &&__ref, _A &&...__args) -> + decltype((__OCTA_FWD(_D, __ref).*__pmf)(__OCTA_FWD(_A, __args)...)) { + return (__OCTA_FWD(_D, __ref).*__pmf)(__OCTA_FWD(_A, __args)...); } - template - inline auto __octa_rof_invoke(PMF &&pmf, P &&ptr, A &&...args) -> - decltype(((*__OCTA_FWD(P, ptr)).*__OCTA_FWD(PMF, pmf))(__OCTA_FWD(A, args)...)) { - return ((*__OCTA_FWD(P, ptr)).*__OCTA_FWD(PMF, pmf))(__OCTA_FWD(A, args)...); + template + inline auto __octa_rof_invoke(_PMF &&__pmf, _P &&__ptr, _A &&...__args) -> + decltype(((*__OCTA_FWD(_P, __ptr)).*__OCTA_FWD(_PMF, __pmf)) + (__OCTA_FWD(_A, __args)...)) { + return ((*__OCTA_FWD(_P, __ptr)).*__OCTA_FWD(_PMF, __pmf)) + (__OCTA_FWD(_A, __args)...); } #undef __OCTA_FWD template struct __OctaResultOf {}; - template - struct __OctaResultOf(), __octa_declval()...)))> { - using type = decltype(__octa_rof_invoke(__octa_declval(), - __octa_declval()...)); + template + struct __OctaResultOf<_F(_A...), decltype(void(__octa_rof_invoke( + __octa_declval<_F>(), __octa_declval<_A>()...)))> { + using type = decltype(__octa_rof_invoke(__octa_declval<_F>(), + __octa_declval<_A>()...)); }; - template struct __OctaResultOfBase: __OctaResultOf {}; + template struct __OctaResultOfBase: __OctaResultOf<_T> {}; - template - using ResultOf = typename __OctaResultOfBase::Type; + template + using ResultOf = typename __OctaResultOfBase<_T>::Type; /* enable if */ - template struct __OctaEnableIf {}; + template struct __OctaEnableIf {}; - template struct __OctaEnableIf { typedef T Type; }; + template struct __OctaEnableIf { typedef _T Type; }; - template - using EnableIf = typename __OctaEnableIf::Type; + template + using EnableIf = typename __OctaEnableIf<_B, _T>::Type; /* decay */ - template + template struct __OctaDecay { private: - typedef RemoveReference U; + typedef RemoveReference<_T> _U; public: - typedef Conditional::value, - RemoveExtent *, - Conditional::value, AddPointer, RemoveCv> + typedef Conditional::value, + RemoveExtent<_U> *, + Conditional::value, AddPointer<_U>, RemoveCv<_U>> > Type; }; - template - using Decay = typename __OctaDecay::Type; + template + using Decay = typename __OctaDecay<_T>::Type; /* common type */ - template struct __OctaCommonType; + template struct __OctaCommonType; - template struct __OctaCommonType { - typedef Decay Type; + template struct __OctaCommonType<_T> { + typedef Decay<_T> Type; }; - template struct __OctaCommonType { - typedef Decay() - : __octa_declval())> Type; + template struct __OctaCommonType<_T, _U> { + typedef Decay() + : __octa_declval<_U>())> Type; }; - template - struct __OctaCommonType { - typedef typename __OctaCommonType::Type, - V...>::Type Type; + template + struct __OctaCommonType<_T, _U, _V...> { + typedef typename __OctaCommonType::Type, + _V...>::Type Type; }; - template - using CommonType = typename __OctaCommonType::Type; + template + using CommonType = typename __OctaCommonType<_T, _U, _V...>::Type; /* aligned storage */ - template struct __OctaAlignedTest { + template struct __OctaAlignedTest { union type { - uchar data[N]; - octa::max_align_t align; + uchar __data[_N]; + octa::max_align_t __align; }; }; - template struct __OctaAlignedStorage { + template struct __OctaAlignedStorage { struct type { - alignas(A) uchar data[N]; + alignas(_A) uchar __data[_N]; }; }; - template::Type) - > using AlignedStorage = typename __OctaAlignedStorage::Type; + template::Type) + > using AlignedStorage = typename __OctaAlignedStorage<_N, _A>::Type; /* aligned union */ - template struct __OctaAlignMax; + template struct __OctaAlignMax; - template struct __OctaAlignMax { - static constexpr size_t value = N; + template struct __OctaAlignMax<_N> { + static constexpr size_t value = _N; }; - template struct __OctaAlignMax { - static constexpr size_t value = (N1 > N2) ? N1 : N2; + template struct __OctaAlignMax<_N1, _N2> { + static constexpr size_t value = (_N1 > _N2) ? _N1 : _N2; }; - template - struct __OctaAlignMax { + template + struct __OctaAlignMax<_N1, _N2, _N...> { static constexpr size_t value - = __OctaAlignMax<__OctaAlignMax::value, N...>::value; + = __OctaAlignMax<__OctaAlignMax<_N1, _N2>::value, _N...>::value; }; - template struct __OctaAlignedUnion { - static constexpr size_t alignment_value - = __OctaAlignMax::value; + template struct __OctaAlignedUnion { + static constexpr size_t __alignment_value + = __OctaAlignMax::value; struct type { - alignas(alignment_value) uchar data[__OctaAlignMax::value]; + alignas(__alignment_value) uchar __data[__OctaAlignMax<_N, + sizeof(_T)...>::value]; }; }; - template - using AlignedUnion = typename __OctaAlignedUnion::Type; + template + using AlignedUnion = typename __OctaAlignedUnion<_N, _T...>::Type; /* underlying type */ /* gotta wrap, in a struct otherwise clang ICEs... */ - template struct __OctaUnderlyingType { - typedef __underlying_type(T) Type; + template struct __OctaUnderlyingType { + typedef __underlying_type(_T) Type; }; - template - using UnderlyingType = typename __OctaUnderlyingType::Type; + template + using UnderlyingType = typename __OctaUnderlyingType<_T>::Type; } #endif \ No newline at end of file diff --git a/octa/utility.h b/octa/utility.h index dfcaaaa..53d832c 100644 --- a/octa/utility.h +++ b/octa/utility.h @@ -13,67 +13,67 @@ namespace octa { /* move */ - template - static inline constexpr RemoveReference &&move(T &&v) { - return static_cast &&>(v); + template + static inline constexpr RemoveReference<_T> &&move(_T &&__v) { + return static_cast &&>(__v); } /* forward */ - template - static inline constexpr T &&forward(RemoveReference &v) { - return static_cast(v); + template + static inline constexpr _T &&forward(RemoveReference<_T> &__v) { + return static_cast<_T &&>(__v); } - template - static inline constexpr T &&forward(RemoveReference &&v) { - return static_cast(v); + template + static inline constexpr _T &&forward(RemoveReference<_T> &&__v) { + return static_cast<_T &&>(__v); } /* declval */ - template AddRvalueReference declval(); + template AddRvalueReference<_T> declval(); /* swap */ - template + template struct __OctaSwapTest { - template struct __OctaTest {}; - template static char __octa_test(__OctaTest *); - template static int __octa_test(...); - static constexpr bool value = (sizeof(__octa_test(0)) == sizeof(char)); + template struct __Test {}; + template static char __test(__Test<_U, &_U::swap> *); + template static int __test(...); + static constexpr bool value = (sizeof(__test<_T>(0)) == sizeof(char)); }; - template inline void __octa_swap(T &a, T &b, EnableIf< - __OctaSwapTest::value, bool + template inline void __octa_swap(_T &__a, _T &__b, EnableIf< + __OctaSwapTest<_T>::value, bool > = true) { - a.swap(b); + __a.swap(__b); } - template inline void __octa_swap(T &a, T &b, EnableIf< - !__OctaSwapTest::value, bool + template inline void __octa_swap(_T &__a, _T &__b, EnableIf< + !__OctaSwapTest<_T>::value, bool > = true) { - T c(move(a)); - a = move(b); - b = move(c); + _T __c(octa::move(__a)); + __a = octa::move(__b); + __b = octa::move(__c); } - template void swap(T &a, T &b) { - __octa_swap(a, b); + template void swap(_T &__a, _T &__b) { + __octa_swap(__a, __b); } - template void swap(T (&a)[N], T (&b)[N]) { - for (size_t i = 0; i < N; ++i) { - swap(a[i], b[i]); + template void swap(_T (&__a)[_N], _T (&__b)[_N]) { + for (size_t __i = 0; __i < _N; ++__i) { + octa::swap(__a[__i], __b[__i]); } } /* pair */ - template + template struct Pair { - T first; - U second; + _T first; + _U second; Pair() = default; ~Pair() = default; @@ -81,46 +81,48 @@ namespace octa { Pair(const Pair &) = default; Pair(Pair &&) = default; - Pair(const T &x, const U &y): first(x), second(y) {} + Pair(const _T &__x, const _U &__y): first(__x), second(__y) {} - template - Pair(TT &&x, UU &&y): first(forward(x)), second(forward(y)) {} + template + Pair(_TT &&__x, _UU &&__y): + first(octa::forward<_TT>(__x)), second(octa::forward<_UU>(__y)) {} - template - Pair(const Pair &v): first(v.first), second(v.second) {} + template + Pair(const Pair<_TT, _UU> &__v): first(__v.first), second(__v.second) {} - template - Pair(Pair &&v): first(move(v.first)), second(move(v.second)) {} + template + Pair(Pair<_TT, _UU> &&__v): + first(octa::move(__v.first)), second(octa::move(__v.second)) {} - Pair &operator=(const Pair &v) { - first = v.first; - second = v.second; + Pair &operator=(const Pair &__v) { + first = __v.first; + second = __v.second; return *this; } - template - Pair &operator=(const Pair &v) { - first = v.first; - second = v.second; + template + Pair &operator=(const Pair<_TT, _UU> &__v) { + first = __v.first; + second = __v.second; return *this; } - Pair &operator=(Pair &&v) { - first = move(v.first); - second = move(v.second); + Pair &operator=(Pair &&__v) { + first = octa::move(__v.first); + second = octa::move(__v.second); return *this; } - template - Pair &operator=(Pair &&v) { - first = forward(v.first); - second = forward(v.second); + template + Pair &operator=(Pair<_TT, _UU> &&__v) { + first = octa::forward<_TT>(__v.first); + second = octa::forward<_UU>(__v.second); return *this; } - void swap(Pair &v) { - octa::swap(first, v.first); - octa::swap(second, v.second); + void swap(Pair &__v) { + octa::swap(first, __v.first); + octa::swap(second, __v.second); } }; } diff --git a/octa/vector.h b/octa/vector.h index 71dd27b..26d8ffc 100644 --- a/octa/vector.h +++ b/octa/vector.h @@ -17,298 +17,297 @@ #include "octa/initializer_list.h" namespace octa { - template + template class Vector { - T *p_buf; - size_t p_len, p_cap; + _T *__buf; + size_t __len, __cap; - void insert_base(size_t idx, size_t n) { - if (p_len + n > p_cap) reserve(p_len + n); - p_len += n; - for (size_t i = p_len - 1; i > idx + n - 1; --i) { - p_buf[i] = move(p_buf[i - n]); + void __insert_base(size_t __idx, size_t __n) { + if (__len + __n > __cap) reserve(__len + __n); + __len += __n; + for (size_t __i = __len - 1; __i > __idx + __n - 1; --__i) { + __buf[__i] = octa::move(__buf[__i - __n]); } } - template - void ctor_from_range(R &range, EnableIf - ::value, bool + template + void __ctor_from_range(_R &__range, octa::EnableIf< + octa::IsFiniteRandomAccessRange<_R>::value, bool > = true) { - RangeSize len = range.size(); - reserve(len); - p_len = len; - for (size_t i = 0; !range.empty(); range.pop_front()) { - new (&p_buf[i]) T(range.front()); - ++i; + octa::RangeSize<_R> __l = __range.size(); + reserve(__l); + __len = __l; + for (size_t __i = 0; !__range.empty(); __range.pop_front()) { + new (&__buf[__i]) _T(__range.front()); + ++__i; } } - template - void ctor_from_range(R &range, EnableIf - ::value, bool + template + void __ctor_from_range(_R &__range, EnableIf< + !octa::IsFiniteRandomAccessRange<_R>::value, bool > = true) { - size_t i = 0; - for (; !range.empty(); range.pop_front()) { - reserve(i + 1); - new (&p_buf[i]) T(range.front()); - ++i; - p_len = i; + size_t __i = 0; + for (; !__range.empty(); __range.pop_front()) { + reserve(__i + 1); + new (&__buf[__i]) _T(__range.front()); + ++__i; + __len = __i; } } public: enum { MIN_SIZE = 8 }; - typedef size_t SizeType; - typedef ptrdiff_t DiffType; - typedef T ValType; - typedef T &RefType; - typedef const T &ConstRefType; - typedef T *PtrType; - typedef const T *ConstPtrType; - typedef PointerRange< T> RangeType; - typedef PointerRange ConstRangeType; + typedef size_t SizeType; + typedef ptrdiff_t DiffType; + typedef _T ValType; + typedef _T &RefType; + typedef const _T &ConstRefType; + typedef _T *PtrType; + typedef const _T *ConstPtrType; + typedef PointerRange< _T> RangeType; + typedef PointerRange ConstRangeType; - Vector(): p_buf(nullptr), p_len(0), p_cap(0) {} + Vector(): __buf(nullptr), __len(0), __cap(0) {} - explicit Vector(size_t n, const T &val = T()): Vector() { - p_buf = (T *)new uchar[n * sizeof(T)]; - p_len = p_cap = n; - T *cur = p_buf, *last = p_buf + n; - while (cur != last) new (cur++) T(val); + explicit Vector(size_t __n, const _T &__val = _T()): Vector() { + __buf = (_T *)new uchar[__n * sizeof(_T)]; + __len = __cap = __n; + _T *__cur = __buf, *__last = __buf + __n; + while (__cur != __last) new (__cur++) _T(__val); } - Vector(const Vector &v): Vector() { - *this = v; + Vector(const Vector &__v): Vector() { + *this = __v; } - Vector(Vector &&v): p_buf(v.p_buf), p_len(v.p_len), p_cap(v.p_cap) { - v.p_buf = nullptr; - v.p_len = v.p_cap = 0; + Vector(Vector &&__v): __buf(__v.__buf), __len(__v.__len), + __cap(__v.__cap) { + __v.__buf = nullptr; + __v.__len = __v.__cap = 0; } - Vector(InitializerList v): Vector() { - size_t len = v.end() - v.begin(); - const T *ptr = v.begin(); - reserve(len); - for (size_t i = 0; i < len; ++i) - new (&p_buf[i]) T(ptr[i]); - p_len = len; + Vector(InitializerList<_T> __v): Vector() { + size_t __l = __v.end() - __v.begin(); + const _T *__ptr = __v.begin(); + reserve(__l); + for (size_t __i = 0; __i < __l; ++__i) + new (&__buf[__i]) _T(__ptr[__i]); + __len = __l; } - template Vector(R range): Vector() { - ctor_from_range(range); + template Vector(_R __range): Vector() { + __ctor_from_range(__range); } ~Vector() { clear(); - delete[] (uchar *)p_buf; - p_buf = nullptr; - p_cap = 0; + delete[] (uchar *)__buf; } void clear() { - if (p_len > 0 && !octa::IsPod()) { - T *cur = p_buf, *last = p_buf + p_len; - while (cur != last) (*cur++).~T(); + if (__len > 0 && !octa::IsPod<_T>()) { + _T *__cur = __buf, *__last = __buf + __len; + while (__cur != __last) (*__cur++).~_T(); } - p_len = 0; + __len = 0; } - Vector &operator=(const Vector &v) { - if (this == &v) return *this; + Vector<_T> &operator=(const Vector<_T> &__v) { + if (this == &__v) return *this; clear(); - reserve(v.p_cap); - p_len = v.p_len; - if (octa::IsPod()) { - memcpy(p_buf, v.p_buf, p_len * sizeof(T)); + reserve(__v.__cap); + __len = __v.__len; + if (octa::IsPod<_T>()) { + memcpy(__buf, __v.__buf, __len * sizeof(_T)); } else { - T *cur = p_buf, *last = p_buf + p_len; - T *vbuf = v.p_buf; - while (cur != last) { - new (cur++) T(*vbuf++); + _T *__cur = __buf, *__last = __buf + __len; + _T *__vbuf = __v.__buf; + while (__cur != __last) { + new (__cur++) _T(*__vbuf++); } } return *this; } - Vector &operator=(Vector &&v) { + Vector<_T> &operator=(Vector<_T> &&__v) { clear(); - delete[] (uchar *)p_buf; - p_len = v.p_len; - p_cap = v.p_cap; - p_buf = v.disown(); + delete[] (uchar *)__buf; + __len = __v.__len; + __cap = __v.__cap; + __buf = __v.disown(); return *this; } - Vector &operator=(InitializerList il) { + Vector<_T> &operator=(InitializerList<_T> __il) { clear(); - size_t ilen = il.end() - il.begin(); - reserve(ilen); - if (octa::IsPod()) { - memcpy(p_buf, il.begin(), ilen); + size_t __ilen = __il.end() - __il.begin(); + reserve(__ilen); + if (octa::IsPod<_T>()) { + memcpy(__buf, __il.begin(), __ilen); } else { - T *buf = p_buf, *ibuf = il.begin(), *last = il.end(); - while (ibuf != last) { - new (buf++) T(*ibuf++); + _T *__tbuf = __buf, *__ibuf = __il.begin(), *__last = __il.end(); + while (__ibuf != __last) { + new (__tbuf++) _T(*__ibuf++); } } - p_len = ilen; + __len = __ilen; return *this; } - template - Vector &operator=(R range) { + template + Vector<_T> &operator=(_R __range) { clear(); - ctor_from_range(range); + __ctor_from_range(__range); } - void resize(size_t n, const T &v = T()) { - size_t len = p_len; - reserve(n); - p_len = n; - if (octa::IsPod()) { - for (size_t i = len; i < p_len; ++i) { - p_buf[i] = T(v); + void resize(size_t __n, const _T &__v = _T()) { + size_t __l = __len; + reserve(__n); + __len = __n; + if (octa::IsPod<_T>()) { + for (size_t __i = __l; __i < __len; ++__i) { + __buf[__i] = _T(__v); } } else { - T *first = p_buf + len; - T *last = p_buf + p_len; - while (first != last) new (first++) T(v); + _T *__first = __buf + __l; + _T *__last = __buf + __len; + while (__first != __last) new (__first++) _T(__v); } } - void reserve(size_t n) { - if (n <= p_cap) return; - size_t oc = p_cap; - if (!oc) { - p_cap = max(n, size_t(MIN_SIZE)); + void reserve(size_t __n) { + if (__n <= __cap) return; + size_t __oc = __cap; + if (!__oc) { + __cap = octa::max(__n, size_t(MIN_SIZE)); } else { - while (p_cap < n) p_cap *= 2; + while (__cap < __n) __cap *= 2; } - T *tmp = (T *)new uchar[p_cap * sizeof(T)]; - if (oc > 0) { - if (octa::IsPod()) { - memcpy(tmp, p_buf, p_len * sizeof(T)); + _T *__tmp = (_T *)new uchar[__cap * sizeof(_T)]; + if (__oc > 0) { + if (octa::IsPod<_T>()) { + memcpy(__tmp, __buf, __len * sizeof(_T)); } else { - T *cur = p_buf, *tcur = tmp, *last = tmp + p_len; - while (tcur != last) { - new (tcur++) T(move(*cur)); - (*cur).~T(); - ++cur; + _T *__cur = __buf, *__tcur = __tmp, *__last = __tmp + __len; + while (__tcur != __last) { + new (__tcur++) _T(octa::move(*__cur)); + (*__cur).~_T(); + ++__cur; } } - delete[] (uchar *)p_buf; + delete[] (uchar *)__buf; } - p_buf = tmp; + __buf = __tmp; } - T &operator[](size_t i) { return p_buf[i]; } - const T &operator[](size_t i) const { return p_buf[i]; } + _T &operator[](size_t __i) { return __buf[__i]; } + const _T &operator[](size_t __i) const { return __buf[__i]; } - T &at(size_t i) { return p_buf[i]; } - const T &at(size_t i) const { return p_buf[i]; } + _T &at(size_t __i) { return __buf[__i]; } + const _T &at(size_t __i) const { return __buf[__i]; } - T &push(const T &v) { - if (p_len == p_cap) reserve(p_len + 1); - new (&p_buf[p_len]) T(v); - return p_buf[p_len++]; + _T &push(const _T &__v) { + if (__len == __cap) reserve(__len + 1); + new (&__buf[__len]) _T(__v); + return __buf[__len++]; } - T &push() { - if (p_len == p_cap) reserve(p_len + 1); - new (&p_buf[p_len]) T; - return p_buf[p_len++]; + _T &push() { + if (__len == __cap) reserve(__len + 1); + new (&__buf[__len]) _T; + return __buf[__len++]; } - template - T &emplace_back(U &&...args) { - if (p_len == p_cap) reserve(p_len + 1); - new (&p_buf[p_len]) T(forward(args)...); - return p_buf[p_len++]; + template + _T &emplace_back(_U &&...__args) { + if (__len == __cap) reserve(__len + 1); + new (&__buf[__len]) _T(octa::forward<_U>(__args)...); + return __buf[__len++]; } void pop() { - if (!octa::IsPod()) { - p_buf[--p_len].~T(); + if (!octa::IsPod<_T>()) { + __buf[--__len].~_T(); } else { - --p_len; + --__len; } } - T &front() { return p_buf[0]; } - const T &front() const { return p_buf[0]; }; + _T &front() { return __buf[0]; } + const _T &front() const { return __buf[0]; }; - T &back() { return p_buf[p_len - 1]; } - const T &back() const { return p_buf[p_len - 1]; } + _T &back() { return __buf[__len - 1]; } + const _T &back() const { return __buf[__len - 1]; } - T *data() { return p_buf; } - const T *data() const { return p_buf; } + _T *data() { return __buf; } + const _T *data() const { return __buf; } - size_t size() const { return p_len; } - size_t capacity() const { return p_cap; } + size_t size() const { return __len; } + size_t capacity() const { return __cap; } - bool empty() const { return (p_len == 0); } + bool empty() const { return (__len == 0); } - bool in_range(size_t idx) { return idx < p_len; } - bool in_range(int idx) { return idx >= 0 && size_t(idx) < p_len; } - bool in_range(const T *ptr) { - return ptr >= p_buf && ptr < &p_buf[p_len]; + bool in_range(size_t __idx) { return __idx < __len; } + bool in_range(int __idx) { return __idx >= 0 && size_t(__idx) < __len; } + bool in_range(const _T *__ptr) { + return __ptr >= __buf && __ptr < &__buf[__len]; } - T *disown() { - T *r = p_buf; - p_buf = nullptr; - p_len = p_cap = 0; - return r; + _T *disown() { + _T *__r = __buf; + __buf = nullptr; + __len = __cap = 0; + return __r; } - T *insert(size_t idx, T &&v) { - insert_base(idx, 1); - p_buf[idx] = move(v); - return &p_buf[idx]; + _T *insert(size_t __idx, _T &&__v) { + __insert_base(__idx, 1); + __buf[__idx] = octa::move(__v); + return &__buf[__idx]; } - T *insert(size_t idx, const T &v) { - insert_base(idx, 1); - p_buf[idx] = v; - return &p_buf[idx]; + _T *insert(size_t __idx, const _T &__v) { + __insert_base(__idx, 1); + __buf[__idx] = __v; + return &__buf[__idx]; } - T *insert(size_t idx, size_t n, const T &v) { - insert_base(idx, n); - for (size_t i = 0; i < n; ++i) { - p_buf[idx + i] = v; + _T *insert(size_t __idx, size_t __n, const _T &__v) { + __insert_base(__idx, __n); + for (size_t __i = 0; __i < __n; ++__i) { + __buf[__idx + __i] = __v; } - return &p_buf[idx]; + return &__buf[__idx]; } - template - T *insert_range(size_t idx, U range) { - size_t len = range.size(); - insert_base(idx, len); - for (size_t i = 0; i < len; ++i) { - p_buf[idx + i] = range.front(); - range.pop_front(); + template + _T *insert_range(size_t __idx, _U __range) { + size_t __l = __range.size(); + __insert_base(__idx, __l); + for (size_t __i = 0; __i < __l; ++__i) { + __buf[__idx + __i] = __range.front(); + __range.pop_front(); } - return &p_buf[idx]; + return &__buf[__idx]; } - T *insert(size_t idx, InitializerList il) { - return insert_range(idx, octa::each(il)); + _T *insert(size_t __idx, InitializerList<_T> __il) { + return insert_range(__idx, octa::each(__il)); } RangeType each() { - return PointerRange(p_buf, p_buf + p_len); + return RangeType(__buf, __buf + __len); } ConstRangeType each() const { - return PointerRange(p_buf, p_buf + p_len); + return ConstRangeType(__buf, __buf + __len); } - void swap(Vector &v) { - octa::swap(p_len, v.p_len); - octa::swap(p_cap, v.p_cap); - octa::swap(p_buf, v.p_buf); + void swap(Vector &__v) { + octa::swap(__len, __v.__len); + octa::swap(__cap, __v.__cap); + octa::swap(__buf, __v.__buf); } }; }