diff --git a/ostd/algorithm.hh b/ostd/algorithm.hh index e6112a8..150eaee 100644 --- a/ostd/algorithm.hh +++ b/ostd/algorithm.hh @@ -65,10 +65,10 @@ inline auto is_partitioned(F &&func) { namespace detail { template static void insort(R range, C &compare) { - RangeSize rlen = range.size(); - for (RangeSize i = 1; i < rlen; ++i) { - RangeSize j = i; - RangeValue v(std::move(range[i])); + range_size_t rlen = range.size(); + for (range_size_t i = 1; i < rlen; ++i) { + range_size_t j = i; + range_value_t v(std::move(range[i])); while (j > 0 && !compare(range[j - 1], v)) { range[j] = range[j - 1]; --j; @@ -79,12 +79,12 @@ namespace detail { template static void hs_sift_down( - R range, RangeSize s, RangeSize e, C &compare + R range, range_size_t s, range_size_t e, C &compare ) { - RangeSize r = s; + range_size_t r = s; while ((r * 2 + 1) <= e) { - RangeSize ch = r * 2 + 1; - RangeSize sw = r; + range_size_t ch = r * 2 + 1; + range_size_t sw = r; if (compare(range[sw], range[ch])) { sw = ch; } @@ -103,15 +103,15 @@ namespace detail { template static void heapsort(R range, C &compare) { - RangeSize len = range.size(); - RangeSize st = (len - 2) / 2; + range_size_t len = range.size(); + range_size_t st = (len - 2) / 2; for (;;) { detail::hs_sift_down(range, st, len - 1, compare); if (st-- == 0) { break; } } - RangeSize e = len - 1; + range_size_t e = len - 1; while (e > 0) { using std::swap; swap(range[e], range[0]); @@ -121,7 +121,7 @@ namespace detail { } template - static void introloop(R range, C &compare, RangeSize depth) { + static void introloop(R range, C &compare, range_size_t depth) { using std::swap; if (range.size() <= 10) { detail::insort(range, compare); @@ -132,7 +132,7 @@ namespace detail { return; } swap(range[range.size() / 2], range.back()); - RangeSize pi = 0; + range_size_t pi = 0; R pr = range; pr.pop_back(); for (; !pr.empty(); pr.pop_front()) { @@ -151,7 +151,7 @@ namespace detail { inline void introsort(R range, C &compare) { detail::introloop( range, compare, - static_cast>(2 * (log(range.size()) / log(2))) + static_cast>(2 * (log(range.size()) / log(2))) ); } } /* namespace detail */ @@ -172,7 +172,7 @@ inline auto sort_cmp(C &&compare) { template inline R sort(R range) { - return sort_cmp(range, std::less>()); + return sort_cmp(range, std::less>()); } inline auto sort() { return [](auto &&obj) { return sort(std::forward(obj)); }; @@ -531,8 +531,8 @@ inline auto find_one_of(R &&values) { } template -inline RangeSize count(R range, T const &v) { - RangeSize ret = 0; +inline range_size_t count(R range, T const &v) { + range_size_t ret = 0; for (; !range.empty(); range.pop_front()) { if (range.front() == v) { ++ret; @@ -549,8 +549,8 @@ inline auto count(T &&v) { } template -inline RangeSize count_if(R range, P pred) { - RangeSize ret = 0; +inline range_size_t count_if(R range, P pred) { + range_size_t ret = 0; for (; !range.empty(); range.pop_front()) { if (pred(range.front())) { ++ret; @@ -567,8 +567,8 @@ inline auto count_if(F &&func) { } template -inline RangeSize count_if_not(R range, P pred) { - RangeSize ret = 0; +inline range_size_t count_if_not(R range, P pred) { + range_size_t ret = 0; for (; !range.empty(); range.pop_front()) { if (!pred(range.front())) { ++ret; @@ -775,52 +775,52 @@ inline auto foldr_f(T &&init, F &&func) { } template -struct MapRange: InputRange> { - using Category = RangeCategory; - using Value = R; - using Reference = R; - using Size = RangeSize; - using Difference = RangeDifference; +struct map_range: input_range> { + using range_category = range_category_t; + using value_type = R; + using reference = R; + using size_type = range_size_t; + using difference_type = range_difference_t; private: T p_range; std::decay_t p_func; public: - MapRange() = delete; + map_range() = delete; template - MapRange(T const &range, FF &&func): + map_range(T const &range, FF &&func): p_range(range), p_func(std::forward(func)) {} - MapRange(MapRange const &it): + map_range(map_range const &it): p_range(it.p_range), p_func(it.p_func) {} - MapRange(MapRange &&it): + map_range(map_range &&it): p_range(std::move(it.p_range)), p_func(std::move(it.p_func)) {} - MapRange &operator=(MapRange const &v) { + map_range &operator=(map_range const &v) { p_range = v.p_range; p_func = v.p_func; return *this; } - MapRange &operator=(MapRange &&v) { + map_range &operator=(map_range &&v) { p_range = std::move(v.p_range); p_func = std::move(v.p_func); return *this; } bool empty() const { return p_range.empty(); } - RangeSize size() const { return p_range.size(); } + range_size_t size() const { return p_range.size(); } - bool equals_front(MapRange const &r) const { + bool equals_front(map_range const &r) const { return p_range.equals_front(r.p_range); } - bool equals_back(MapRange const &r) const { + bool equals_back(map_range const &r) const { return p_range.equals_front(r.p_range); } - RangeDifference distance_front(MapRange const &r) const { + range_difference_t distance_front(map_range const &r) const { return p_range.distance_front(r.p_range); } - RangeDifference distance_back(MapRange const &r) const { + range_difference_t distance_back(map_range const &r) const { return p_range.distance_back(r.p_range); } @@ -830,42 +830,42 @@ public: bool push_front() { return p_range.pop_front(); } bool push_back() { return p_range.push_back(); } - RangeSize pop_front_n(RangeSize n) { + range_size_t pop_front_n(range_size_t n) { p_range.pop_front_n(n); } - RangeSize pop_back_n(RangeSize n) { + range_size_t pop_back_n(range_size_t n) { p_range.pop_back_n(n); } - RangeSize push_front_n(RangeSize n) { + range_size_t push_front_n(range_size_t n) { return p_range.push_front_n(n); } - RangeSize push_back_n(RangeSize n) { + range_size_t push_back_n(range_size_t 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 { + R operator[](range_size_t idx) const { return p_func(p_range[idx]); } - MapRange slice(RangeSize start, RangeSize end) { - return MapRange(p_range.slice(start, end), p_func); + map_range slice(range_size_t start, range_size_t end) { + return map_range(p_range.slice(start, end), p_func); } }; namespace detail { template using MapReturnType = decltype( - std::declval()(std::declval>()) + std::declval()(std::declval>()) ); } template -inline MapRange> map(R range, F func) { - return MapRange>(range, std::move(func)); +inline map_range> map(R range, F func) { + return map_range>(range, std::move(func)); } template @@ -876,12 +876,14 @@ inline auto map(F &&func) { } template -struct FilterRange: InputRange> { - using Category = std::common_type_t, ForwardRangeTag>; - using Value = RangeValue; - using Reference = RangeReference; - using Size = RangeSize; - using Difference = RangeDifference; +struct filter_range: input_range> { + using range_category = std::common_type_t< + range_category_t, forward_range_tag + >; + using value_type = range_value_t; + using reference = range_reference_t; + using size_type = range_size_t; + using difference_type = range_difference_t; private: T p_range; @@ -894,31 +896,31 @@ private: } public: - FilterRange() = delete; + filter_range() = delete; template - FilterRange(T const &range, P &&pred): + filter_range(T const &range, P &&pred): p_range(range), p_pred(std::forward

(pred)) { advance_valid(); } - FilterRange(FilterRange const &it): + filter_range(filter_range const &it): p_range(it.p_range), p_pred(it.p_pred) { advance_valid(); } - FilterRange(FilterRange &&it): + filter_range(filter_range &&it): p_range(std::move(it.p_range)), p_pred(std::move(it.p_pred)) { advance_valid(); } - FilterRange &operator=(FilterRange const &v) { + filter_range &operator=(filter_range const &v) { p_range = v.p_range; p_pred = v.p_pred; advance_valid(); return *this; } - FilterRange &operator=(FilterRange &&v) { + filter_range &operator=(filter_range &&v) { p_range = std::move(v.p_range); p_pred = std::move(v.p_pred); advance_valid(); @@ -927,7 +929,7 @@ public: bool empty() const { return p_range.empty(); } - bool equals_front(FilterRange const &r) const { + bool equals_front(filter_range const &r) const { return p_range.equals_front(r.p_range); } @@ -937,19 +939,19 @@ public: return ret; } - RangeReference front() const { return p_range.front(); } + range_reference_t front() const { return p_range.front(); } }; namespace detail { template using FilterPred = std::enable_if_t()(std::declval>())), bool + decltype(std::declval

()(std::declval>())), bool >, P>; } template -inline FilterRange> filter(R range, P pred) { - return FilterRange(range, std::move(pred)); +inline filter_range> filter(R range, P pred) { + return filter_range(range, std::move(pred)); } template diff --git a/ostd/ext/sdl_rwops.hh b/ostd/ext/sdl_rwops.hh index 63afe24..328dc99 100644 --- a/ostd/ext/sdl_rwops.hh +++ b/ostd/ext/sdl_rwops.hh @@ -21,7 +21,7 @@ namespace sdl { #ifdef OSTD_EXT_SDL_USE_SDL1 using SDLRWopsOffset = int; #else -using SDLRWopsOffset = Int64; +using SDLRWopsOffset = int64_t; #endif inline SDL_RWops *stream_to_rwops(Stream &s) { diff --git a/ostd/filesystem.hh b/ostd/filesystem.hh index 7ead38d..392589a 100644 --- a/ostd/filesystem.hh +++ b/ostd/filesystem.hh @@ -225,11 +225,11 @@ inline void swap(FileInfo &a, FileInfo &b) { a.swap(b); } -struct DirectoryRange; +struct directory_range; #ifndef OSTD_PLATFORM_WIN32 struct DirectoryStream { - friend struct DirectoryRange; + friend struct directory_range; DirectoryStream(): p_d(), p_de(), p_path() {} DirectoryStream(DirectoryStream const &) = delete; @@ -324,7 +324,7 @@ struct DirectoryStream { swap(p_path, s.p_path); } - DirectoryRange iter(); + directory_range iter(); private: static bool pop_front(DIR *d, struct dirent **de) { @@ -366,7 +366,7 @@ private: #else /* OSTD_PLATFORM_WIN32 */ struct DirectoryStream { - friend struct DirectoryRange; + friend struct directory_range; DirectoryStream(): p_handle(INVALID_HANDLE_VALUE), p_data(), p_path() {} DirectoryStream(DirectoryStream const &) = delete; @@ -495,7 +495,7 @@ struct DirectoryStream { swap(p_path, s.p_path); } - DirectoryRange iter(); + directory_range iter(); private: bool pop_front() { @@ -529,18 +529,18 @@ inline void swap(DirectoryStream &a, DirectoryStream &b) { a.swap(b); } -struct DirectoryRange: InputRange { - using Category = InputRangeTag; - using Value = FileInfo; - using Reference = FileInfo; - using Size = size_t; - using Difference = long; +struct directory_range: input_range { + using range_category = input_range_tag; + using value_type = FileInfo; + using reference = FileInfo; + using size_type = size_t; + using difference_type = long; - DirectoryRange() = delete; - DirectoryRange(DirectoryStream &s): p_stream(&s) {} - DirectoryRange(DirectoryRange const &r): p_stream(r.p_stream) {} + directory_range() = delete; + directory_range(DirectoryStream &s): p_stream(&s) {} + directory_range(directory_range const &r): p_stream(r.p_stream) {} - DirectoryRange &operator=(DirectoryRange const &r) { + directory_range &operator=(directory_range const &r) { p_stream = r.p_stream; return *this; } @@ -557,7 +557,7 @@ struct DirectoryRange: InputRange { return p_stream->front(); } - bool equals_front(DirectoryRange const &s) const { + bool equals_front(directory_range const &s) const { return p_stream == s.p_stream; } @@ -565,8 +565,8 @@ private: DirectoryStream *p_stream; }; -inline DirectoryRange DirectoryStream::iter() { - return DirectoryRange(*this); +inline directory_range DirectoryStream::iter() { + return directory_range(*this); } namespace detail { diff --git a/ostd/format.hh b/ostd/format.hh index bddb3df..1bd1d56 100644 --- a/ostd/format.hh +++ b/ostd/format.hh @@ -757,8 +757,8 @@ namespace detail { template size_t write_val(R &writer, bool escape, T const &val) const { /* stuff fhat can be custom-formatted goes first */ - if constexpr(FmtTofmtTest>) { - TostrRange sink(writer); + if constexpr(FmtTofmtTest>) { + tostr_range sink(writer); to_format(val, sink, *this); return sink.get_written(); } diff --git a/ostd/io.hh b/ostd/io.hh index f4a88d9..6934a6d 100644 --- a/ostd/io.hh +++ b/ostd/io.hh @@ -152,11 +152,11 @@ static FileStream err(stderr); namespace detail { /* lightweight output range for direct stdout */ - struct StdoutRange: OutputRange { - using Value = char; - using Reference = char &; - using Size = size_t; - using Difference = ptrdiff_t; + struct StdoutRange: output_range { + using value_type = char; + using reference = char &; + using size_type = size_t; + using difference_type = ptrdiff_t; StdoutRange() {} bool put(char c) { diff --git a/ostd/range.hh b/ostd/range.hh index 10ca50b..9853936 100644 --- a/ostd/range.hh +++ b/ostd/range.hh @@ -21,244 +21,245 @@ namespace ostd { -struct InputRangeTag {}; -struct OutputRangeTag {}; -struct ForwardRangeTag: InputRangeTag {}; -struct BidirectionalRangeTag: ForwardRangeTag {}; -struct RandomAccessRangeTag: BidirectionalRangeTag {}; -struct FiniteRandomAccessRangeTag: RandomAccessRangeTag {}; -struct ContiguousRangeTag: FiniteRandomAccessRangeTag {}; +struct input_range_tag {}; +struct output_range_tag {}; +struct forward_range_tag: input_range_tag {}; +struct bidirectional_range_tag: forward_range_tag {}; +struct random_access_range_tag: bidirectional_range_tag {}; +struct finite_random_access_range_tag: random_access_range_tag {}; +struct ContiguousRangeTag: finite_random_access_range_tag {}; template -struct RangeHalf; +struct range_half; -#define OSTD_RANGE_TRAIT(Name) \ +#define OSTD_RANGE_TRAIT(Name, Member) \ namespace detail { \ template \ - struct Range##Name##Test { \ + struct range_##Name##_test { \ template \ - static char test(std::remove_reference_t *); \ + static char test(std::remove_reference_t *); \ template \ static int test(...); \ static constexpr bool value = (sizeof(test(0)) == sizeof(char)); \ }; \ - template::value> \ - struct Range##Name##Base {}; \ + template::value> \ + struct range_##Name##_base {}; \ template \ - struct Range##Name##Base { \ - using Type = typename T::Name; \ + struct range_##Name##_base { \ + using type = typename T::Member; \ }; \ } \ template \ -using Range##Name = typename detail::Range##Name##Base::Type; +using range_##Name##_t = typename detail::range_##Name##_base::type; -OSTD_RANGE_TRAIT(Category) -OSTD_RANGE_TRAIT(Size) -OSTD_RANGE_TRAIT(Value) -OSTD_RANGE_TRAIT(Reference) -OSTD_RANGE_TRAIT(Difference) +OSTD_RANGE_TRAIT(category, range_category) +OSTD_RANGE_TRAIT(size, size_type) +OSTD_RANGE_TRAIT(value, value_type) +OSTD_RANGE_TRAIT(reference, reference) +OSTD_RANGE_TRAIT(difference, difference_type) #undef OSTD_RANGE_TRAIT namespace detail { template - static char is_range_test( - typename U::Category *, typename U::Size *, - typename U::Difference *, typename U::Value *, - std::remove_reference_t * + static char is_range_test_f( + typename U::range_category *, typename U::size_type *, + typename U::difference_type *, typename U::value_type *, + std::remove_reference_t * ); template - static int is_range_test(...); + static int is_range_test_f(...); - template constexpr bool IsRangeTest = - (sizeof(is_range_test(0, 0, 0, 0, 0)) == sizeof(char)); + template constexpr bool is_range_test = + (sizeof(is_range_test_f(0, 0, 0, 0, 0)) == sizeof(char)); } // is input range namespace detail { template - constexpr bool IsInputRangeCore = - std::is_convertible_v, InputRangeTag>; + constexpr bool is_input_range_core = + std::is_convertible_v, input_range_tag>; - template> - constexpr bool IsInputRangeBase = false; + template> + constexpr bool is_input_range_base = false; template - constexpr bool IsInputRangeBase = detail::IsInputRangeCore; + constexpr bool is_input_range_base = detail::is_input_range_core; } template -constexpr bool IsInputRange = detail::IsInputRangeBase; +constexpr bool is_input_range = detail::is_input_range_base; // is forward range namespace detail { template - constexpr bool IsForwardRangeCore = - std::is_convertible_v, ForwardRangeTag>; + constexpr bool is_forward_range_core = + std::is_convertible_v, forward_range_tag>; - template> - constexpr bool IsForwardRangeBase = false; + template> + constexpr bool is_forward_range_base = false; template - constexpr bool IsForwardRangeBase = detail::IsForwardRangeCore; + constexpr bool is_forward_range_base = detail::is_forward_range_core; } template -constexpr bool IsForwardRange = detail::IsForwardRangeBase; +constexpr bool is_forward_range = detail::is_forward_range_base; // is bidirectional range namespace detail { template - constexpr bool IsBidirectionalRangeCore = - std::is_convertible_v, BidirectionalRangeTag>; + constexpr bool is_bidirectional_range_core = + std::is_convertible_v, bidirectional_range_tag>; - template> - constexpr bool IsBidirectionalRangeBase = false; + template> + constexpr bool is_bidirectional_range_base = false; template - constexpr bool IsBidirectionalRangeBase = - detail::IsBidirectionalRangeCore; + constexpr bool is_bidirectional_range_base = + detail::is_bidirectional_range_core; } -template constexpr bool IsBidirectionalRange = - detail::IsBidirectionalRangeBase; +template constexpr bool is_bidirectional_range = + detail::is_bidirectional_range_base; // is random access range namespace detail { template - constexpr bool IsRandomAccessRangeCore = - std::is_convertible_v, RandomAccessRangeTag>; + constexpr bool is_random_access_range_core = + std::is_convertible_v, random_access_range_tag>; - template> - constexpr bool IsRandomAccessRangeBase = false; + template> + constexpr bool is_random_access_range_base = false; template - constexpr bool IsRandomAccessRangeBase = - detail::IsRandomAccessRangeCore; + constexpr bool is_random_access_range_base = + detail::is_random_access_range_core; } -template constexpr bool IsRandomAccessRange = - detail::IsRandomAccessRangeBase; +template constexpr bool is_random_access_range = + detail::is_random_access_range_base; // is finite random access range namespace detail { template - constexpr bool IsFiniteRandomAccessRangeCore = - std::is_convertible_v, FiniteRandomAccessRangeTag>; + constexpr bool is_finite_random_access_range_core = + std::is_convertible_v, finite_random_access_range_tag>; - template> - constexpr bool IsFiniteRandomAccessRangeBase = false; + template> + constexpr bool is_finite_random_access_range_base = false; template - constexpr bool IsFiniteRandomAccessRangeBase = - detail::IsFiniteRandomAccessRangeCore; + constexpr bool is_finite_random_access_range_base = + detail::is_finite_random_access_range_core; } -template constexpr bool IsFiniteRandomAccessRange = - detail::IsFiniteRandomAccessRangeBase; +template constexpr bool is_finite_random_access_range = + detail::is_finite_random_access_range_base; // is infinite random access range -template constexpr bool IsInfiniteRandomAccessRange = - IsRandomAccessRange && !IsFiniteRandomAccessRange; +template constexpr bool is_infinite_random_access_range = + is_random_access_range && !is_finite_random_access_range; // is contiguous range namespace detail { template - constexpr bool IsContiguousRangeCore = - std::is_convertible_v, ContiguousRangeTag>; + constexpr bool is_contiguous_range_core = + std::is_convertible_v, ContiguousRangeTag>; - template> - constexpr bool IsContiguousRangeBase = false; + template> + constexpr bool is_contiguous_range_base = false; template - constexpr bool IsContiguousRangeBase = - detail::IsContiguousRangeCore; + constexpr bool is_contiguous_range_base = + detail::is_contiguous_range_core; } -template constexpr bool IsContiguousRange = - detail::IsContiguousRangeBase; +template constexpr bool is_contiguous_range = + detail::is_contiguous_range_base; // is output range namespace detail { template - struct OutputRangeTest { + struct output_range_test { template - struct Test {}; + struct test_t {}; template - static char test(Test *); + static char test(test_t *); template static int test(...); static constexpr bool value = (sizeof(test(0)) == sizeof(char)); }; template - constexpr bool IsOutputRangeCore = - std::is_convertible_v, OutputRangeTag> || ( - IsInputRange && ( - detail::OutputRangeTest const &>::value || - detail::OutputRangeTest &&>::value || - detail::OutputRangeTest >::value + constexpr bool is_output_range_core = + std::is_convertible_v, output_range_tag> || ( + is_input_range && ( + detail::output_range_test const &>::value || + detail::output_range_test &&>::value || + detail::output_range_test >::value ) ); - template> - constexpr bool IsOutputRangeBase = false; + template> + constexpr bool is_output_range_base = false; template - constexpr bool IsOutputRangeBase = detail::IsOutputRangeCore; + constexpr bool is_output_range_base = detail::is_output_range_core; } -template constexpr bool IsOutputRange = detail::IsOutputRangeBase; +template +constexpr bool is_output_range = detail::is_output_range_base; namespace detail { // range iterator template - struct RangeIterator { - RangeIterator(): p_range(), p_init(false) {} - explicit RangeIterator(T const &range): p_range(), p_init(true) { + struct range_iterator { + range_iterator(): p_range(), p_init(false) {} + explicit range_iterator(T const &range): p_range(), p_init(true) { ::new(&get_ref()) T(range); } - explicit RangeIterator(T &&range): p_range(), p_init(true) { + explicit range_iterator(T &&range): p_range(), p_init(true) { ::new(&get_ref()) T(std::move(range)); } - RangeIterator(const RangeIterator &v): p_range(), p_init(true) { + range_iterator(const range_iterator &v): p_range(), p_init(true) { ::new(&get_ref()) T(v.get_ref()); } - RangeIterator(RangeIterator &&v): p_range(), p_init(true) { + range_iterator(range_iterator &&v): p_range(), p_init(true) { ::new(&get_ref()) T(std::move(v.get_ref())); } - RangeIterator &operator=(const RangeIterator &v) { + range_iterator &operator=(const range_iterator &v) { destroy(); ::new(&get_ref()) T(v.get_ref()); p_init = true; return *this; } - RangeIterator &operator=(RangeIterator &&v) { + range_iterator &operator=(range_iterator &&v) { destroy(); swap(v); return *this; } - ~RangeIterator() { + ~range_iterator() { destroy(); } - RangeIterator &operator++() { + range_iterator &operator++() { get_ref().pop_front(); return *this; } - RangeReference operator*() const { + range_reference_t operator*() const { return get_ref().front(); } - bool operator!=(RangeIterator) const { return !get_ref().empty(); } - void swap(RangeIterator &v) { + bool operator!=(range_iterator) const { return !get_ref().empty(); } + void swap(range_iterator &v) { using std::swap; swap(get_ref(). v.get_ref()); swap(p_init, v.p_init); @@ -280,15 +281,15 @@ namespace detail { // range half template -struct HalfRange; +struct half_range; namespace detail { - template> + template> struct RangeAdd; template struct RangeAdd { - using Diff = RangeDifference; + using Diff = range_difference_t; static Diff add_n(R &half, Diff n) { if (n < 0) { @@ -306,7 +307,7 @@ namespace detail { template struct RangeAdd { - using Diff = RangeDifference; + using Diff = range_difference_t; static Diff add_n(R &half, Diff n) { if (n < 0) { @@ -325,60 +326,60 @@ namespace detail { namespace detail { template - struct RangeIteratorTag { + struct range_iteratorTag { /* better range types all become random access iterators */ using Type = std::random_access_iterator_tag; }; template<> - struct RangeIteratorTag { + struct range_iteratorTag { using Type = std::input_iterator_tag; }; template<> - struct RangeIteratorTag { + struct range_iteratorTag { using Type = std::output_iterator_tag; }; template<> - struct RangeIteratorTag { + struct range_iteratorTag { using Type = std::forward_iterator_tag; }; template<> - struct RangeIteratorTag { + struct range_iteratorTag { using Type = std::bidirectional_iterator_tag; }; } template -struct RangeHalf { +struct range_half { private: T p_range; public: using Range = T; - using iterator_category = typename detail::RangeIteratorTag::Type; - using value_type = RangeValue; - using difference_type = RangeDifference; - using pointer = RangeValue *; - using reference = RangeReference; + using iterator_category = typename detail::range_iteratorTag::Type; + using value_type = range_value_t; + using difference_type = range_difference_t; + using pointer = range_value_t *; + using reference = range_reference_t; - RangeHalf() = delete; - RangeHalf(T const &range): p_range(range) {} + range_half() = delete; + range_half(T const &range): p_range(range) {} template>> - RangeHalf(RangeHalf const &half): p_range(half.p_range) {} + range_half(range_half const &half): p_range(half.p_range) {} - RangeHalf(RangeHalf const &half): p_range(half.p_range) {} - RangeHalf(RangeHalf &&half): p_range(std::move(half.p_range)) {} + range_half(range_half const &half): p_range(half.p_range) {} + range_half(range_half &&half): p_range(std::move(half.p_range)) {} - RangeHalf &operator=(RangeHalf const &half) { + range_half &operator=(range_half const &half) { p_range = half.p_range; return *this; } - RangeHalf &operator=(RangeHalf &&half) { + range_half &operator=(range_half &&half) { p_range = std::move(half.p_range); return *this; } @@ -386,110 +387,110 @@ public: bool next() { return p_range.pop_front(); } bool prev() { return p_range.push_front(); } - RangeSize next_n(RangeSize n) { + range_size_t next_n(range_size_t n) { return p_range.pop_front_n(n); } - RangeSize prev_n(RangeSize n) { + range_size_t prev_n(range_size_t n) { return p_range.push_front_n(n); } - RangeDifference add_n(RangeDifference n) { - return detail::RangeAdd>::add_n(*this, n); + range_difference_t add_n(range_difference_t n) { + return detail::RangeAdd>::add_n(*this, n); } - RangeDifference sub_n(RangeDifference n) { - return detail::RangeAdd>::sub_n(*this, n); + range_difference_t sub_n(range_difference_t n) { + return detail::RangeAdd>::sub_n(*this, n); } - RangeReference get() const { + range_reference_t get() const { return p_range.front(); } - RangeDifference distance(RangeHalf const &half) const { + range_difference_t distance(range_half const &half) const { return p_range.distance_front(half.p_range); } - bool equals(RangeHalf const &half) const { + bool equals(range_half const &half) const { return p_range.equals_front(half.p_range); } - bool operator==(RangeHalf const &half) const { + bool operator==(range_half const &half) const { return equals(half); } - bool operator!=(RangeHalf const &half) const { + bool operator!=(range_half const &half) const { return !equals(half); } /* iterator like interface */ - RangeReference operator*() const { + range_reference_t operator*() const { return p_range.front(); } - RangeReference operator[](RangeSize idx) const { + range_reference_t operator[](range_size_t idx) const { return p_range[idx]; } - RangeHalf &operator++() { + range_half &operator++() { next(); return *this; } - RangeHalf operator++(int) { - RangeHalf tmp(*this); + range_half operator++(int) { + range_half tmp(*this); next(); return tmp; } - RangeHalf &operator--() { + range_half &operator--() { prev(); return *this; } - RangeHalf operator--(int) { - RangeHalf tmp(*this); + range_half operator--(int) { + range_half tmp(*this); prev(); return tmp; } - RangeHalf operator+(RangeDifference n) const { - RangeHalf tmp(*this); + range_half operator+(range_difference_t n) const { + range_half tmp(*this); tmp.add_n(n); return tmp; } - RangeHalf operator-(RangeDifference n) const { - RangeHalf tmp(*this); + range_half operator-(range_difference_t n) const { + range_half tmp(*this); tmp.sub_n(n); return tmp; } - RangeHalf &operator+=(RangeDifference n) { + range_half &operator+=(range_difference_t n) { add_n(n); return *this; } - RangeHalf &operator-=(RangeDifference n) { + range_half &operator-=(range_difference_t n) { sub_n(n); return *this; } T iter() const { return p_range; } - HalfRange iter(RangeHalf const &other) const { - return HalfRange(*this, other); + half_range iter(range_half const &other) const { + return half_range(*this, other); } - RangeValue *data() { return p_range.data(); } - RangeValue const *data() const { return p_range.data(); } + range_value_t *data() { return p_range.data(); } + range_value_t const *data() const { return p_range.data(); } }; template -inline RangeDifference operator-( - RangeHalf const &lhs, RangeHalf const &rhs +inline range_difference_t operator-( + range_half const &lhs, range_half const &rhs ) { return rhs.distance(lhs); } namespace detail { template - RangeSize pop_front_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) { + range_size_t pop_front_n(R &range, range_size_t n) { + for (range_size_t i = 0; i < n; ++i) { if (!range.pop_front()) { return i; } @@ -498,8 +499,8 @@ namespace detail { } template - RangeSize pop_back_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) { + range_size_t pop_back_n(R &range, range_size_t n) { + for (range_size_t i = 0; i < n; ++i) { if (!range.pop_back()) { return i; } @@ -508,8 +509,8 @@ namespace detail { } template - RangeSize push_front_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) { + range_size_t push_front_n(R &range, range_size_t n) { + for (range_size_t i = 0; i < n; ++i) { if (!range.push_front()) { return i; } @@ -518,8 +519,8 @@ namespace detail { } template - RangeSize push_back_n(R &range, RangeSize n) { - for (RangeSize i = 0; i < n; ++i) { + range_size_t push_back_n(R &range, range_size_t n) { + for (range_size_t i = 0; i < n; ++i) { if (!range.push_back()) { return i; } @@ -529,27 +530,27 @@ namespace detail { } template -struct ReverseRange; +struct reverse_range; template -struct MoveRange; +struct move_range; template -struct EnumeratedRange; +struct enumerated_range; template -struct TakeRange; +struct take_range; template -struct ChunksRange; +struct chunks_range; template -struct JoinRange; +struct join_range; template -struct ZipRange; +struct zip_range; template -struct InputRange { - detail::RangeIterator begin() const { - return detail::RangeIterator(*static_cast(this)); +struct input_range { + detail::range_iterator begin() const { + return detail::range_iterator(*static_cast(this)); } - detail::RangeIterator end() const { - return detail::RangeIterator(); + detail::range_iterator end() const { + return detail::range_iterator(); } template @@ -576,44 +577,44 @@ struct InputRange { return B(*static_cast(this)); } - ReverseRange reverse() const { - return ReverseRange(iter()); + reverse_range reverse() const { + return reverse_range(iter()); } - MoveRange movable() const { - return MoveRange(iter()); + move_range movable() const { + return move_range(iter()); } - EnumeratedRange enumerate() const { - return EnumeratedRange(iter()); + enumerated_range enumerate() const { + return enumerated_range(iter()); } template - TakeRange take(Size n) const { - return TakeRange(iter(), n); + take_range take(Size n) const { + return take_range(iter(), n); } template - ChunksRange chunks(Size n) const { - return ChunksRange(iter(), n); + chunks_range chunks(Size n) const { + return chunks_range(iter(), n); } template - JoinRange join(R1 r1, RR ...rr) const { - return JoinRange(iter(), std::move(r1), std::move(rr)...); + join_range join(R1 r1, RR ...rr) const { + return join_range(iter(), std::move(r1), std::move(rr)...); } template - ZipRange zip(R1 r1, RR ...rr) const { - return ZipRange(iter(), std::move(r1), std::move(rr)...); + zip_range zip(R1 r1, RR ...rr) const { + return zip_range(iter(), std::move(r1), std::move(rr)...); } - RangeHalf half() const { - return RangeHalf(iter()); + range_half half() const { + return range_half(iter()); } template - std::enable_if_t, Size> copy(OR &&orange, Size n = -1) { + std::enable_if_t, Size> copy(OR &&orange, Size n = -1) { B r(*static_cast(this)); Size on = n; for (; n && !r.empty(); --n) { @@ -716,15 +717,15 @@ struct InputRange { }; template -struct OutputRange { - using Category = OutputRangeTag; +struct output_range { + using range_category = output_range_tag; }; template -inline RangeSize range_put_n( - R &range, RangeValue const *p, RangeSize n +inline range_size_t range_put_n( + R &range, range_value_t const *p, range_size_t n ) { - RangeSize on = n; + range_size_t on = n; for (; n && range.put(*p++); --n); return (on - n); } @@ -857,40 +858,39 @@ inline auto citer(T const &r) -> decltype(ranged_traits::iter(r)) { } template -struct HalfRange: InputRange> { - using Category = RangeCategory ; - using Value = RangeValue ; - using Reference = RangeReference ; - using Size = RangeSize ; - using Difference = RangeDifference; +struct half_range: input_range> { + using range_category = range_category_t ; + using value_type = range_value_t ; + using reference = range_reference_t ; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: - using Rtype = typename T::Range; T p_beg; T p_end; public: - HalfRange() = delete; - HalfRange(HalfRange const &range): + half_range() = delete; + half_range(half_range const &range): p_beg(range.p_beg), p_end(range.p_end) {} - HalfRange(HalfRange &&range): + half_range(half_range &&range): p_beg(std::move(range.p_beg)), p_end(std::move(range.p_end)) {} - HalfRange(T const &beg, T const &end): + half_range(T const &beg, T const &end): p_beg(beg),p_end(end) {} - HalfRange(T &&beg, T &&end): + half_range(T &&beg, T &&end): p_beg(std::move(beg)), p_end(std::move(end)) {} - HalfRange &operator=(HalfRange const &range) { + half_range &operator=(half_range const &range) { p_beg = range.p_beg; p_end = range.p_end; return *this; } - HalfRange &operator=(HalfRange &&range) { + half_range &operator=(half_range &&range) { p_beg = std::move(range.p_beg); p_end = std::move(range.p_end); return *this; @@ -917,94 +917,94 @@ public: return p_end.next(); } - RangeReference front() const { return *p_beg; } - RangeReference back() const { return *(p_end - 1); } + reference front() const { return *p_beg; } + reference back() const { return *(p_end - 1); } - bool equals_front(HalfRange const &range) const { + bool equals_front(half_range const &range) const { return p_beg == range.p_beg; } - bool equals_back(HalfRange const &range) const { + bool equals_back(half_range const &range) const { return p_end == range.p_end; } - RangeDifference distance_front(HalfRange const &range) const { + difference_type distance_front(half_range const &range) const { return range.p_beg - p_beg; } - RangeDifference distance_back(HalfRange const &range) const { + difference_type distance_back(half_range const &range) const { return range.p_end - p_end; } - RangeSize size() const { return p_end - p_beg; } + size_type size() const { return p_end - p_beg; } - HalfRange slice(RangeSize start, RangeSize end) const { - return HalfRange(p_beg + start, p_beg + end); + half_range slice(size_type start, size_type end) const { + return half_range{p_beg + start, p_beg + end}; } - RangeReference operator[](RangeSize idx) const { + reference operator[](size_type idx) const { return p_beg[idx]; } - bool put(RangeValue const &v) { + bool put(value_type const &v) { return p_beg.range().put(v); } - bool put(RangeValue &&v) { + bool put(value_type &&v) { return p_beg.range().put(std::move(v)); } - RangeValue *data() { return p_beg.data(); } - RangeValue const *data() const { return p_beg.data(); } + value_type *data() { return p_beg.data(); } + value_type const *data() const { return p_beg.data(); } }; template -struct ReverseRange: InputRange> { - using Category = std::common_type_t< - RangeCategory, FiniteRandomAccessRangeTag +struct reverse_range: input_range> { + using range_category = std::common_type_t< + range_category_t, finite_random_access_range_tag >; - using Value = RangeValue ; - using Reference = RangeReference ; - using Size = RangeSize ; - using Difference = RangeDifference; + using value_type = range_value_t ; + using reference = range_reference_t ; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: T p_range; public: - ReverseRange() = delete; - ReverseRange(T const &range): p_range(range) {} - ReverseRange(ReverseRange const &it): p_range(it.p_range) {} - ReverseRange(ReverseRange &&it): p_range(std::move(it.p_range)) {} + reverse_range() = delete; + reverse_range(T const &range): p_range(range) {} + reverse_range(reverse_range const &it): p_range(it.p_range) {} + reverse_range(reverse_range &&it): p_range(std::move(it.p_range)) {} - ReverseRange &operator=(ReverseRange const &v) { + reverse_range &operator=(reverse_range const &v) { p_range = v.p_range; return *this; } - ReverseRange &operator=(ReverseRange &&v) { + reverse_range &operator=(reverse_range &&v) { p_range = std::move(v.p_range); return *this; } - ReverseRange &operator=(T const &v) { + reverse_range &operator=(T const &v) { p_range = v; return *this; } - ReverseRange &operator=(T &&v) { + reverse_range &operator=(T &&v) { p_range = std::move(v); return *this; } bool empty() const { return p_range.empty(); } - Size size() const { return p_range.size(); } + size_type size() const { return p_range.size(); } - bool equals_front(ReverseRange const &r) const { + bool equals_front(reverse_range const &r) const { return p_range.equals_back(r.p_range); } - bool equals_back(ReverseRange const &r) const { + bool equals_back(reverse_range const &r) const { return p_range.equals_front(r.p_range); } - RangeDifference distance_front(ReverseRange const &r) const { + difference_type distance_front(reverse_range const &r) const { return -p_range.distance_back(r.p_range); } - RangeDifference distance_back(ReverseRange const &r) const { + difference_type distance_back(reverse_range const &r) const { return -p_range.distance_front(r.p_range); } @@ -1014,73 +1014,73 @@ public: bool push_front() { return p_range.push_back(); } bool push_back() { return p_range.push_front(); } - Size pop_front_n(Size n) { return p_range.pop_front_n(n); } - Size pop_back_n(Size n) { return p_range.pop_back_n(n); } + size_type pop_front_n(size_type n) { return p_range.pop_front_n(n); } + size_type pop_back_n(size_type n) { return p_range.pop_back_n(n); } - Size push_front_n(Size n) { return p_range.push_front_n(n); } - Size push_back_n(Size n) { return p_range.push_back_n(n); } + size_type push_front_n(size_type n) { return p_range.push_front_n(n); } + size_type push_back_n(size_type n) { return p_range.push_back_n(n); } - Reference front() const { return p_range.back(); } - Reference back() const { return p_range.front(); } + reference front() const { return p_range.back(); } + reference back() const { return p_range.front(); } - Reference operator[](Size i) const { return p_range[size() - i - 1]; } + reference operator[](size_type i) const { return p_range[size() - i - 1]; } - ReverseRange slice(Size start, Size end) const { - Size len = p_range.size(); - return ReverseRange(p_range.slice(len - end, len - start)); + reverse_range slice(size_type start, size_type end) const { + size_type len = p_range.size(); + return reverse_range{p_range.slice(len - end, len - start)}; } }; template -struct MoveRange: InputRange> { - using Category = std::common_type_t< - RangeCategory, FiniteRandomAccessRangeTag +struct move_range: input_range> { + using range_category = std::common_type_t< + range_category_t, finite_random_access_range_tag >; - using Value = RangeValue ; - using Reference = RangeValue &&; - using Size = RangeSize ; - using Difference = RangeDifference; + using value_type = range_value_t ; + using reference = range_value_t &&; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: T p_range; public: - MoveRange() = delete; - MoveRange(T const &range): p_range(range) {} - MoveRange(MoveRange const &it): p_range(it.p_range) {} - MoveRange(MoveRange &&it): p_range(std::move(it.p_range)) {} + move_range() = delete; + move_range(T const &range): p_range(range) {} + move_range(move_range const &it): p_range(it.p_range) {} + move_range(move_range &&it): p_range(std::move(it.p_range)) {} - MoveRange &operator=(MoveRange const &v) { + move_range &operator=(move_range const &v) { p_range = v.p_range; return *this; } - MoveRange &operator=(MoveRange &&v) { + move_range &operator=(move_range &&v) { p_range = std::move(v.p_range); return *this; } - MoveRange &operator=(T const &v) { + move_range &operator=(T const &v) { p_range = v; return *this; } - MoveRange &operator=(T &&v) { + move_range &operator=(T &&v) { p_range = std::move(v); return *this; } bool empty() const { return p_range.empty(); } - Size size() const { return p_range.size(); } + size_type size() const { return p_range.size(); } - bool equals_front(MoveRange const &r) const { + bool equals_front(move_range const &r) const { return p_range.equals_front(r.p_range); } - bool equals_back(MoveRange const &r) const { + bool equals_back(move_range const &r) const { return p_range.equals_back(r.p_range); } - RangeDifference distance_front(MoveRange const &r) const { + difference_type distance_front(move_range const &r) const { return p_range.distance_front(r.p_range); } - RangeDifference distance_back(MoveRange const &r) const { + difference_type distance_back(move_range const &r) const { return p_range.distance_back(r.p_range); } @@ -1090,42 +1090,42 @@ public: bool push_front() { return p_range.push_front(); } bool push_back() { return p_range.push_back(); } - Size pop_front_n(Size n) { return p_range.pop_front_n(n); } - Size pop_back_n(Size n) { return p_range.pop_back_n(n); } + size_type pop_front_n(size_type n) { return p_range.pop_front_n(n); } + size_type pop_back_n(size_type n) { return p_range.pop_back_n(n); } - Size push_front_n(Size n) { return p_range.push_front_n(n); } - Size push_back_n(Size n) { return p_range.push_back_n(n); } + size_type push_front_n(size_type n) { return p_range.push_front_n(n); } + size_type push_back_n(size_type n) { return p_range.push_back_n(n); } - Reference front() const { return std::move(p_range.front()); } - Reference back() const { return std::move(p_range.back()); } + reference front() const { return std::move(p_range.front()); } + reference back() const { return std::move(p_range.back()); } - Reference operator[](Size i) const { return std::move(p_range[i]); } + reference operator[](size_type i) const { return std::move(p_range[i]); } - MoveRange slice(Size start, Size end) const { - return MoveRange(p_range.slice(start, end)); + move_range slice(size_type start, size_type end) const { + return move_range{p_range.slice(start, end)}; } - bool put(Value const &v) { return p_range.put(v); } - bool put(Value &&v) { return p_range.put(std::move(v)); } + bool put(value_type const &v) { return p_range.put(v); } + bool put(value_type &&v) { return p_range.put(std::move(v)); } }; template -struct NumberRange: InputRange> { - using Category = ForwardRangeTag; - using Value = T; - using Reference = T; - using Size = size_t; - using Difference = ptrdiff_t; +struct number_range: input_range> { + using range_category = forward_range_tag; + using value_type = T; + using reference = T; + using size_type = size_t; + using difference_type = ptrdiff_t; - NumberRange() = delete; - NumberRange(T a, T b, T step = T(1)): + number_range() = delete; + number_range(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) {} + number_range(T v): p_a(0), p_b(v), p_step(1) {} bool empty() const { return p_a * p_step >= p_b * p_step; } - bool equals_front(NumberRange const &range) const { + bool equals_front(number_range const &range) const { return p_a == range.p_a; } @@ -1137,62 +1137,66 @@ private: }; template -inline NumberRange range(T a, T b, T step = T(1)) { - return NumberRange(a, b, step); +inline number_range range(T a, T b, T step = T(1)) { + return number_range(a, b, step); } template -inline NumberRange range(T v) { - return NumberRange(v); +inline number_range range(T v) { + return number_range(v); } template -struct EnumeratedValue { +struct enumerated_value_t { S index; T value; }; template -struct EnumeratedRange: InputRange> { - using Category = std::common_type_t, ForwardRangeTag>; - using Value = RangeValue; - using Reference = EnumeratedValue, RangeSize>; - using Size = RangeSize; - using Difference = RangeDifference; +struct enumerated_range: input_range> { + using range_category = std::common_type_t< + range_category_t, forward_range_tag + >; + using value_type = range_value_t; + using reference = enumerated_value_t< + range_reference_t, range_size_t + >; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: T p_range; - Size p_index; + size_type p_index; public: - EnumeratedRange() = delete; + enumerated_range() = delete; - EnumeratedRange(T const &range): p_range(range), p_index(0) {} + enumerated_range(T const &range): p_range(range), p_index(0) {} - EnumeratedRange(EnumeratedRange const &it): + enumerated_range(enumerated_range const &it): p_range(it.p_range), p_index(it.p_index) {} - EnumeratedRange(EnumeratedRange &&it): + enumerated_range(enumerated_range &&it): p_range(std::move(it.p_range)), p_index(it.p_index) {} - EnumeratedRange &operator=(EnumeratedRange const &v) { + enumerated_range &operator=(enumerated_range const &v) { p_range = v.p_range; p_index = v.p_index; return *this; } - EnumeratedRange &operator=(EnumeratedRange &&v) { + enumerated_range &operator=(enumerated_range &&v) { p_range = std::move(v.p_range); p_index = v.p_index; return *this; } - EnumeratedRange &operator=(T const &v) { + enumerated_range &operator=(T const &v) { p_range = v; p_index = 0; return *this; } - EnumeratedRange &operator=(T &&v) { + enumerated_range &operator=(T &&v) { p_range = std::move(v); p_index = 0; return *this; @@ -1200,7 +1204,7 @@ public: bool empty() const { return p_range.empty(); } - bool equals_front(EnumeratedRange const &r) const { + bool equals_front(enumerated_range const &r) const { return p_range.equals_front(r.p_range); } @@ -1212,45 +1216,47 @@ public: return false; } - Size pop_front_n(Size n) { - Size ret = p_range.pop_front_n(n); + size_type pop_front_n(size_type n) { + size_type ret = p_range.pop_front_n(n); p_index += ret; return ret; } - Reference front() const { - return Reference{p_index, p_range.front()}; + reference front() const { + return reference{p_index, p_range.front()}; } }; template -struct TakeRange: InputRange> { - using Category = std::common_type_t, ForwardRangeTag>; - using Value = RangeValue ; - using Reference = RangeReference ; - using Size = RangeSize ; - using Difference = RangeDifference; +struct take_range: input_range> { + using range_category = std::common_type_t< + range_category_t, forward_range_tag + >; + using value_type = range_value_t ; + using reference = range_reference_t ; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: T p_range; - Size p_remaining; + size_type p_remaining; public: - TakeRange() = delete; - TakeRange(T const &range, RangeSize rem): + take_range() = delete; + take_range(T const &range, range_size_t rem): p_range(range), p_remaining(rem) {} - TakeRange(TakeRange const &it): + take_range(take_range const &it): p_range(it.p_range), p_remaining(it.p_remaining) {} - TakeRange(TakeRange &&it): + take_range(take_range &&it): p_range(std::move(it.p_range)), p_remaining(it.p_remaining) {} - TakeRange &operator=(TakeRange const &v) { + take_range &operator=(take_range const &v) { p_range = v.p_range; p_remaining = v.p_remaining; return *this; } - TakeRange &operator=(TakeRange &&v) { + take_range &operator=(take_range &&v) { p_range = std::move(v.p_range); p_remaining = v.p_remaining; return *this; @@ -1266,47 +1272,49 @@ public: return false; } - Size pop_front_n(Size n) { - Size ret = p_range.pop_front_n(n); + size_type pop_front_n(size_type n) { + size_type ret = p_range.pop_front_n(n); p_remaining -= ret; return ret; } - Reference front() const { return p_range.front(); } + reference front() const { return p_range.front(); } - bool equals_front(TakeRange const &r) const { + bool equals_front(take_range const &r) const { return p_range.equals_front(r.p_range); } }; template -struct ChunksRange: InputRange> { - using Category = std::common_type_t, ForwardRangeTag>; - using Value = TakeRange ; - using Reference = TakeRange ; - using Size = RangeSize ; - using Difference = RangeDifference; +struct chunks_range: input_range> { + using range_category = std::common_type_t< + range_category_t, forward_range_tag + >; + using value_type = take_range ; + using reference = take_range ; + using size_type = range_size_t ; + using difference_type = range_difference_t; private: T p_range; - Size p_chunksize; + size_type p_chunksize; public: - ChunksRange() = delete; - ChunksRange(T const &range, RangeSize chs): + chunks_range() = delete; + chunks_range(T const &range, range_size_t chs): p_range(range), p_chunksize(chs) {} - ChunksRange(ChunksRange const &it): + chunks_range(chunks_range const &it): p_range(it.p_range), p_chunksize(it.p_chunksize) {} - ChunksRange(ChunksRange &&it): + chunks_range(chunks_range &&it): p_range(std::move(it.p_range)), p_chunksize(it.p_chunksize) {} - ChunksRange &operator=(ChunksRange const &v) { + chunks_range &operator=(chunks_range const &v) { p_range = v.p_range; p_chunksize = v.p_chunksize; return *this; } - ChunksRange &operator=(ChunksRange &&v) { + chunks_range &operator=(chunks_range &&v) { p_range = std::move(v.p_range); p_chunksize = v.p_chunksize; return *this; @@ -1314,16 +1322,16 @@ public: bool empty() const { return p_range.empty(); } - bool equals_front(ChunksRange const &r) const { + bool equals_front(chunks_range const &r) const { return p_range.equals_front(r.p_range); } bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; } - Size pop_front_n(Size n) { + size_type pop_front_n(size_type n) { return p_range.pop_front_n(p_chunksize * n) / p_chunksize; } - Reference front() const { return p_range.take(p_chunksize); } + reference front() const { return p_range.take(p_chunksize); } }; namespace detail { @@ -1351,29 +1359,31 @@ namespace detail { } template -struct JoinRange: InputRange> { - using Category = std::common_type_t...>; - using Value = std::common_type_t...>; - using Reference = std::common_type_t...>; - using Size = std::common_type_t...>; - using Difference = std::common_type_t...>; +struct join_range: input_range> { + using range_category = std::common_type_t< + forward_range_tag, range_category_t... + >; + using value_type = std::common_type_t...>; + using reference = std::common_type_t...>; + using size_type = std::common_type_t...>; + using difference_type = std::common_type_t...>; private: std::tuple p_ranges; public: - JoinRange() = delete; - JoinRange(R const &...ranges): p_ranges(ranges...) {} - JoinRange(R &&...ranges): p_ranges(std::forward(ranges)...) {} - JoinRange(JoinRange const &v): p_ranges(v.p_ranges) {} - JoinRange(JoinRange &&v): p_ranges(std::move(v.p_ranges)) {} + join_range() = delete; + join_range(R const &...ranges): p_ranges(ranges...) {} + join_range(R &&...ranges): p_ranges(std::forward(ranges)...) {} + join_range(join_range const &v): p_ranges(v.p_ranges) {} + join_range(join_range &&v): p_ranges(std::move(v.p_ranges)) {} - JoinRange &operator=(JoinRange const &v) { + join_range &operator=(join_range const &v) { p_ranges = v.p_ranges; return *this; } - JoinRange &operator=(JoinRange &&v) { + join_range &operator=(join_range &&v) { p_ranges = std::move(v.p_ranges); return *this; } @@ -1384,7 +1394,7 @@ public: }, p_ranges); } - bool equals_front(JoinRange const &r) const { + bool equals_front(join_range const &r) const { return std::apply([&r](auto const &...r1) { return std::apply([&](auto const &...r2) { return (... && r1.equals_front(r2)); @@ -1396,50 +1406,52 @@ public: return detail::join_range_pop<0, sizeof...(R)>(p_ranges); } - std::common_type_t...> front() const { + reference front() const { return detail::join_range_front<0, sizeof...(R)>(p_ranges); } }; namespace detail { template - struct ZipValueType { - using Type = std::tuple; + struct zip_value_type { + using type = std::tuple; }; template - struct ZipValueType { - using Type = std::pair; + struct zip_value_type { + using type = std::pair; }; template - using ZipValue = typename detail::ZipValueType::Type; + using zip_value_t = typename detail::zip_value_type::type; } template -struct ZipRange: InputRange> { - using Category = std::common_type_t...>; - using Value = detail::ZipValue...>; - using Reference = detail::ZipValue...>; - using Size = std::common_type_t...>; - using Difference = std::common_type_t...>; +struct zip_range: input_range> { + using range_category = std::common_type_t< + forward_range_tag, range_category_t... + >; + using value_type = detail::zip_value_t...>; + using reference = detail::zip_value_t...>; + using size_type = std::common_type_t...>; + using difference_type = std::common_type_t...>; private: std::tuple p_ranges; public: - ZipRange() = delete; - ZipRange(R const &...ranges): p_ranges(ranges...) {} - ZipRange(R &&...ranges): p_ranges(std::forward(ranges)...) {} - ZipRange(ZipRange const &v): p_ranges(v.p_ranges) {} - ZipRange(ZipRange &&v): p_ranges(std::move(v.p_ranges)) {} + zip_range() = delete; + zip_range(R const &...ranges): p_ranges(ranges...) {} + zip_range(R &&...ranges): p_ranges(std::forward(ranges)...) {} + zip_range(zip_range const &v): p_ranges(v.p_ranges) {} + zip_range(zip_range &&v): p_ranges(std::move(v.p_ranges)) {} - ZipRange &operator=(ZipRange const &v) { + zip_range &operator=(zip_range const &v) { p_ranges = v.p_ranges; return *this; } - ZipRange &operator=(ZipRange &&v) { + zip_range &operator=(zip_range &&v) { p_ranges = std::move(v.p_ranges); return *this; } @@ -1450,7 +1462,7 @@ public: }, p_ranges); } - bool equals_front(ZipRange const &r) const { + bool equals_front(zip_range const &r) const { return std::apply([&r](auto const &...r1) { return std::apply([&](auto const &...r2) { return (... && r1.equals_front(r2)); @@ -1464,42 +1476,42 @@ public: }, p_ranges); } - detail::ZipValue...> front() const { + reference front() const { return std::apply([](auto &&...args) { - return detail::ZipValue...>{args.front()...}; + return reference{args.front()...}; }, p_ranges); } }; template -struct AppenderRange: OutputRange> { - using Value = typename T::value_type; - using Reference = typename T::reference; - using Size = typename T::size_type; - using Difference = typename T::difference_type; +struct appender_range: output_range> { + using value_type = typename T::value_type; + using reference = typename T::reference; + using size_type = typename T::size_type; + using difference_type = typename T::difference_type; - AppenderRange(): p_data() {} - AppenderRange(T const &v): p_data(v) {} - AppenderRange(T &&v): p_data(std::move(v)) {} - AppenderRange(AppenderRange const &v): p_data(v.p_data) {} - AppenderRange(AppenderRange &&v): p_data(std::move(v.p_data)) {} + appender_range(): p_data() {} + appender_range(T const &v): p_data(v) {} + appender_range(T &&v): p_data(std::move(v)) {} + appender_range(appender_range const &v): p_data(v.p_data) {} + appender_range(appender_range &&v): p_data(std::move(v.p_data)) {} - AppenderRange &operator=(AppenderRange const &v) { + appender_range &operator=(appender_range const &v) { p_data = v.p_data; return *this; } - AppenderRange &operator=(AppenderRange &&v) { + appender_range &operator=(appender_range &&v) { p_data = std::move(v.p_data); return *this; } - AppenderRange &operator=(T const &v) { + appender_range &operator=(T const &v) { p_data = v; return *this; } - AppenderRange &operator=(T &&v) { + appender_range &operator=(T &&v) { p_data = std::move(v); return *this; } @@ -1509,8 +1521,8 @@ struct AppenderRange: OutputRange> { void reserve(typename T::size_type cap) { p_data.reserve(cap); } void resize(typename T::size_type len) { p_data.resize(len); } - typename T::size_type size() const { return p_data.size(); } - typename T::size_type capacity() const { return p_data.capacity(); } + size_type size() const { return p_data.size(); } + size_type capacity() const { return p_data.capacity(); } bool put(typename T::const_reference v) { p_data.push_back(v); @@ -1528,86 +1540,86 @@ private: }; template -inline AppenderRange appender() { - return AppenderRange(); +inline appender_range appender() { + return appender_range(); } template -inline AppenderRange appender(T &&v) { - return AppenderRange(std::forward(v)); +inline appender_range appender(T &&v) { + return appender_range(std::forward(v)); } namespace detail { template - struct IteratorRangeTagBase { + struct iterator_range_tag_base { /* fallback, the most basic range */ - using Type = InputRangeTag; + using Type = input_range_tag; }; template<> - struct IteratorRangeTagBase { - using Type = OutputRangeTag; + struct iterator_range_tag_base { + using Type = output_range_tag; }; template<> - struct IteratorRangeTagBase { - using Type = ForwardRangeTag; + struct iterator_range_tag_base { + using Type = forward_range_tag; }; template<> - struct IteratorRangeTagBase { - using Type = BidirectionalRangeTag; + struct iterator_range_tag_base { + using Type = bidirectional_range_tag; }; template<> - struct IteratorRangeTagBase { - using Type = FiniteRandomAccessRangeTag; + struct iterator_range_tag_base { + using Type = finite_random_access_range_tag; }; } template -using IteratorRangeTag = typename detail::IteratorRangeTagBase::Type; +using iterator_range_tag = typename detail::iterator_range_tag_base::Type; template -struct IteratorRange: InputRange> { - using Category = std::conditional_t< +struct iterator_range: input_range> { + using range_category = std::conditional_t< std::is_pointer_v, ContiguousRangeTag, - IteratorRangeTag::iterator_category> + iterator_range_tag::iterator_category> >; - using Value = typename std::iterator_traits::value_type; - using Reference = typename std::iterator_traits::reference; - using Size = std::make_unsigned_t< + using value_type = typename std::iterator_traits::value_type; + using reference = typename std::iterator_traits::reference; + using size_type = std::make_unsigned_t< typename std::iterator_traits::difference_type >; - using Difference = typename std::iterator_traits::difference_type; + using difference_type = typename std::iterator_traits::difference_type; - IteratorRange(T beg = T{}, T end = T{}): p_beg(beg), p_end(end) {} + iterator_range(T beg = T{}, T end = T{}): p_beg(beg), p_end(end) {} template && std::is_pointer_v && std::is_convertible_v >> - IteratorRange(IteratorRange const &v): p_beg(&v[0]), p_end(&v[v.size()]) {} + iterator_range(iterator_range const &v): p_beg(&v[0]), p_end(&v[v.size()]) {} - IteratorRange(IteratorRange const &v): p_beg(v.p_beg), p_end(v.p_end) {} - IteratorRange(IteratorRange &&v): + iterator_range(iterator_range const &v): p_beg(v.p_beg), p_end(v.p_end) {} + iterator_range(iterator_range &&v): p_beg(std::move(v.p_beg)), p_end(std::move(v.p_end)) {} - IteratorRange &operator=(IteratorRange const &v) { + iterator_range &operator=(iterator_range const &v) { p_beg = v.p_beg; p_end = v.p_end; return *this; } - IteratorRange &operator=(IteratorRange &&v) { + iterator_range &operator=(iterator_range &&v) { p_beg = std::move(v.p_beg); p_end = std::move(v.p_end); return *this; } - /* satisfy InputRange / ForwardRange */ + /* satisfy input_range / forward_range */ bool empty() const { return p_beg == p_end; } bool pop_front() { @@ -1621,10 +1633,10 @@ struct IteratorRange: InputRange> { --p_beg; return true; } - Size pop_front_n(Size n) { + size_type pop_front_n(size_type n) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { - Size olen = Size(p_end - p_beg); + size_type olen = size_type(p_end - p_beg); p_beg += n; if (p_beg > p_end) { p_beg = p_end; @@ -1636,7 +1648,7 @@ struct IteratorRange: InputRange> { } } - Size push_front_n(Size n) { + size_type push_front_n(size_type n) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { p_beg -= n; @@ -1646,17 +1658,17 @@ struct IteratorRange: InputRange> { } } - Reference front() const { return *p_beg; } + reference front() const { return *p_beg; } - bool equals_front(IteratorRange const &range) const { + bool equals_front(iterator_range const &range) const { return p_beg == range.p_beg; } - Difference distance_front(IteratorRange const &range) const { + difference_type distance_front(iterator_range const &range) const { return range.p_beg - p_beg; } - /* satisfy BidirectionalRange */ + /* satisfy bidirectional_range */ bool pop_back() { if (p_end == p_beg) { return false; @@ -1668,10 +1680,10 @@ struct IteratorRange: InputRange> { ++p_end; return true; } - Size pop_back_n(Size n) { + size_type pop_back_n(size_type n) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { - Size olen = Size(p_end - p_beg); + size_type olen = size_type(p_end - p_beg); p_end -= n; if (p_end < p_beg) { p_end = p_beg; @@ -1683,7 +1695,7 @@ struct IteratorRange: InputRange> { } } - Size push_back_n(Size n) { + size_type push_back_n(size_type n) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { p_end += n; @@ -1693,34 +1705,34 @@ struct IteratorRange: InputRange> { } } - Reference back() const { return *(p_end - 1); } + reference back() const { return *(p_end - 1); } - bool equals_back(IteratorRange const &range) const { + bool equals_back(iterator_range const &range) const { return p_end == range.p_end; } - ptrdiff_t distance_back(IteratorRange const &range) const { + ptrdiff_t distance_back(iterator_range const &range) const { return range.p_end - p_end; } /* satisfy FiniteRandomAccessRange */ - Size size() const { return Size(p_end - p_beg); } + size_type size() const { return size_type(p_end - p_beg); } - IteratorRange slice(Size start, Size end) const { - return IteratorRange(p_beg + start, p_beg + end); + iterator_range slice(size_type start, size_type end) const { + return iterator_range(p_beg + start, p_beg + end); } - Reference operator[](Size i) const { return p_beg[i]; } + reference operator[](size_type i) const { return p_beg[i]; } - /* satisfy OutputRange */ - bool put(Value const &v) { + /* satisfy output_range */ + bool put(value_type const &v) { if (empty()) { return false; } *(p_beg++) = v; return true; } - bool put(Value &&v) { + bool put(value_type &&v) { if (empty()) { return false; } @@ -1729,15 +1741,17 @@ struct IteratorRange: InputRange> { } template - std::enable_if_t, Size> copy(R &&orange, Size n = -1) { + std::enable_if_t, size_type> copy( + R &&orange, size_type n = -1 + ) { if constexpr(std::is_pointer_v) { - Size c = size(); + size_type c = size(); if (n < c) { c = n; } return range_put_n(orange, p_beg, c); } else { - Size on = n; + size_type on = n; for (; n && !empty(); --n) { if (!orange.put(front())) { break; @@ -1748,21 +1762,23 @@ struct IteratorRange: InputRange> { } } - Size copy(std::remove_cv_t *p, Size n = -1) { + size_type copy(std::remove_cv_t *p, size_type n = -1) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { - Size c = size(); + size_type c = size(); if (n < c) { c = n; } - if constexpr(std::is_pointer_v && std::is_pod_v) { - memcpy(p, p_beg, c * sizeof(Value)); + if constexpr(std::is_pointer_v && std::is_pod_v) { + memcpy(p, p_beg, c * sizeof(value_type)); return c; } else { - return copy(IteratorRange *>(p, p + c), c); + return copy(iterator_range< + std::remove_cv_t * + >(p, p + c), c); } } else { - Size on = n; + size_type on = n; for (; n && !empty(); --n) { *p++ = front(); pop_front(); @@ -1776,18 +1792,18 @@ private: template inline auto range_put_n( - IteratorRange &range, RangeValue> const *p, - RangeSize> n + iterator_range &range, range_value_t> const *p, + range_size_t> n ) { using IC = typename std::iterator_traits::iterator_category; if constexpr(std::is_convertible_v) { - using Value = RangeValue>; + using value_type = range_value_t>; auto ret = range.size(); if (n < ret) { ret = n; } - if constexpr(std::is_pointer_v && std::is_pod_v) { - memcpy(&range.front(), p, ret * sizeof(Value)); + if constexpr(std::is_pointer_v && std::is_pod_v) { + memcpy(&range.front(), p, ret * sizeof(value_type)); range.pop_front_n(ret); } else { for (auto i = ret; i; --i) { @@ -1804,13 +1820,13 @@ inline auto range_put_n( } template -IteratorRange make_range(T beg, T end) { - return IteratorRange{beg, end}; +iterator_range make_range(T beg, T end) { + return iterator_range{beg, end}; } template struct ranged_traits> { - using range = IteratorRange; + using range = iterator_range; static range iter(std::initializer_list il) { return range{il.begin(), il.end()}; @@ -1822,18 +1838,18 @@ struct ranged_traits> { * template, so we also need to define that here explicitly... */ template -IteratorRange iter(std::initializer_list init) noexcept { - return IteratorRange(init.begin(), init.end()); +iterator_range iter(std::initializer_list init) noexcept { + return iterator_range(init.begin(), init.end()); } template -IteratorRange citer(std::initializer_list init) noexcept { - return IteratorRange(init.begin(), init.end()); +iterator_range citer(std::initializer_list init) noexcept { + return iterator_range(init.begin(), init.end()); } template struct ranged_traits { - using range = IteratorRange; + using range = iterator_range; static range iter(T (&array)[N]) { return range{array, array + N}; @@ -1841,8 +1857,8 @@ struct ranged_traits { }; template -inline IteratorRange iter(T *a, T *b) { - return IteratorRange(a, b); +inline iterator_range iter(T *a, T *b) { + return iterator_range(a, b); } /* iter on standard containers */ @@ -1864,7 +1880,7 @@ namespace detail { struct ranged_traits_core && !detail::direct_iter_test >> { - using range = IteratorRange()))>; + using range = iterator_range()))>; static range iter(C &r) { return range{r.begin(), r.end()}; diff --git a/ostd/stream.hh b/ostd/stream.hh index c79db21..9c659a6 100644 --- a/ostd/stream.hh +++ b/ostd/stream.hh @@ -31,7 +31,7 @@ enum class StreamSeek { }; template> -struct StreamRange; +struct stream_range; struct Stream { using Offset = StreamOffset; @@ -111,7 +111,7 @@ struct Stream { } template - StreamRange iter(); + stream_range iter(); template size_t put(T const *v, size_t count) { @@ -141,22 +141,22 @@ struct Stream { }; template -size_t range_put_n(StreamRange &range, T const *p, size_t n); +size_t range_put_n(stream_range &range, T const *p, size_t n); template -struct StreamRange: InputRange> { - using Category = InputRangeTag; - using Value = T; - using Reference = T; - using Size = size_t; - using Difference = StreamOffset; +struct stream_range: input_range> { + using range_category = input_range_tag; + using value_type = T; + using reference = T; + using size_type = size_t; + using difference_type = StreamOffset; template - friend size_t range_put_n(StreamRange &range, TT const *p, size_t n); + friend size_t range_put_n(stream_range &range, TT const *p, size_t n); - StreamRange() = delete; - StreamRange(Stream &s): p_stream(&s), p_size(s.size()) {} - StreamRange(StreamRange const &r): p_stream(r.p_stream), p_size(r.p_size) {} + stream_range() = delete; + stream_range(Stream &s): p_stream(&s), p_size(s.size()) {} + stream_range(stream_range const &r): p_stream(r.p_stream), p_size(r.p_size) {} bool empty() const { return (p_size - p_stream->tell()) < StreamOffset(sizeof(T)); @@ -176,7 +176,7 @@ struct StreamRange: InputRange> { return val; } - bool equals_front(StreamRange const &s) const { + bool equals_front(stream_range const &s) const { return p_stream->tell() == s.p_stream->tell(); } @@ -199,43 +199,43 @@ private: }; template -inline size_t range_put_n(StreamRange &range, T const *p, size_t n) { +inline size_t range_put_n(stream_range &range, T const *p, size_t n) { return range.p_stream->put(p, n); } template -inline StreamRange Stream::iter() { - return StreamRange(*this); +inline stream_range Stream::iter() { + return stream_range(*this); } namespace detail { /* lightweight output range for write/writef on streams */ - struct FmtStreamRange: OutputRange { - using Value = char; - using Reference = char &; - using Size = size_t; - using Difference = ptrdiff_t; + struct fmt_stream_range: output_range { + using value_type = char; + using reference = char &; + using size_type = size_t; + using difference_type = ptrdiff_t; - FmtStreamRange(Stream &s): p_s(s) {} + fmt_stream_range(Stream &s): p_s(s) {} bool put(char c) { return p_s.write_bytes(&c, 1) == 1; } Stream &p_s; }; - inline size_t range_put_n(FmtStreamRange &range, char const *p, size_t n) { + inline size_t range_put_n(fmt_stream_range &range, char const *p, size_t n) { return range.p_s.write_bytes(p, n); } } template inline void Stream::write(T const &v) { - format(detail::FmtStreamRange{*this}, FormatSpec{'s'}, v); + format(detail::fmt_stream_range{*this}, FormatSpec{'s'}, v); } template inline void Stream::writef(string_range fmt, A const &...args) { - format(detail::FmtStreamRange{*this}, fmt, args...); + format(detail::fmt_stream_range{*this}, fmt, args...); } } diff --git a/ostd/string.hh b/ostd/string.hh index 2df2532..c6e5854 100644 --- a/ostd/string.hh +++ b/ostd/string.hh @@ -23,12 +23,12 @@ namespace ostd { template>> -struct basic_char_range: InputRange> { - using Category = ContiguousRangeTag; - using Value = T; - using Reference = T &; - using Size = size_t; - using Difference = ptrdiff_t; +struct basic_char_range: input_range> { + using range_category = ContiguousRangeTag; + using value_type = T; + using reference = T &; + using size_type = size_t; + using difference_type = ptrdiff_t; private: struct Nat {}; @@ -187,7 +187,7 @@ diffsize: } template - std::enable_if_t, size_t> copy(R &&orange, size_t n = -1) { + std::enable_if_t, size_t> copy(R &&orange, size_t n = -1) { return range_put_n(orange, data(), ostd::min(n, size())); } @@ -417,8 +417,8 @@ template< > inline std::basic_string make_string(R range, A const &alloc = A{}) { std::basic_string ret{alloc}; - using C = RangeCategory; - if constexpr(std::is_convertible_v) { + using C = range_category_t; + if constexpr(std::is_convertible_v) { /* finite random access or contiguous */ auto h = range.half(); ret.reserve(range.size()); @@ -433,13 +433,13 @@ inline std::basic_string make_string(R range, A const &alloc = A{}) { } template< - typename R, typename TR = std::char_traits>>, - typename A = std::allocator>> + typename R, typename TR = std::char_traits>>, + typename A = std::allocator>> > -inline std::basic_string>, TR, A> make_string( +inline std::basic_string>, TR, A> make_string( R range, A const &alloc = A{} ) { - return make_string>, TR, A>( + return make_string>, TR, A>( std::move(range), alloc ); } @@ -531,17 +531,17 @@ bool concat(R &&sink, std::initializer_list v, string_range sep = " ") { namespace detail { template - struct TostrRange: OutputRange> { - using Value = char; - using Reference = char &; - using Size = size_t; - using Difference = ptrdiff_t; + struct tostr_range: output_range> { + using value_type = char; + using reference = char &; + using size_type = size_t; + using difference_type = ptrdiff_t; template - friend size_t range_put_n(TostrRange &range, char const *p, size_t n); + friend size_t range_put_n(tostr_range &range, char const *p, size_t n); - TostrRange() = delete; - TostrRange(R &out): p_out(out), p_written(0) {} + tostr_range() = delete; + tostr_range(R &out): p_out(out), p_written(0) {} bool put(char v) { bool ret = p_out.put(v); p_written += ret; @@ -559,7 +559,7 @@ namespace detail { }; template - inline size_t range_put_n(TostrRange &range, char const *p, size_t n) { + inline size_t range_put_n(tostr_range &range, char const *p, size_t n) { size_t ret = range_put_n(range.p_out, p, n); range.p_written += ret; return ret; @@ -603,7 +603,7 @@ struct ToString>> { auto x = appender(); if (concat(x, ostd::iter(v), ", ", ToString< std::remove_const_t + range_reference_t >> >())) { ret += x.get(); @@ -615,14 +615,14 @@ struct ToString>> { template struct ToString>> + detail::StringifyTest>> >> { using Argument = std::remove_cv_t>; using Result = std::string; std::string operator()(T const &v) const { auto app = appender(); - detail::TostrRange> sink(app); + detail::tostr_range> sink(app); if (!v.to_string(sink)) { return std::string{}; } @@ -803,7 +803,7 @@ std::string to_string(std::initializer_list init) { template struct TempCString { private: - std::remove_cv_t> *p_buf; + std::remove_cv_t> *p_buf; bool p_allocated; public: @@ -813,13 +813,13 @@ public: s.p_buf = nullptr; s.p_allocated = false; } - TempCString(R input, std::remove_cv_t> *sbuf, size_t bufsize) + TempCString(R input, std::remove_cv_t> *sbuf, size_t bufsize) : p_buf(nullptr), p_allocated(false) { if (input.empty()) { return; } if (input.size() >= bufsize) { - p_buf = new std::remove_cv_t>[input.size() + 1]; + p_buf = new std::remove_cv_t>[input.size() + 1]; p_allocated = true; } else { p_buf = sbuf; @@ -838,8 +838,8 @@ public: return *this; } - operator std::remove_cv_t> const *() const { return p_buf; } - std::remove_cv_t> const *get() const { return p_buf; } + operator std::remove_cv_t> const *() const { return p_buf; } + std::remove_cv_t> const *get() const { return p_buf; } void swap(TempCString &s) { using std::swap; @@ -855,7 +855,7 @@ inline void swap(TempCString &a, TempCString &b) { template inline TempCString to_temp_cstr( - R input, std::remove_cv_t> *buf, size_t bufsize + R input, std::remove_cv_t> *buf, size_t bufsize ) { return TempCString(input, buf, bufsize); } diff --git a/ostd/unordered_map.hh b/ostd/unordered_map.hh index edbe046..fe55793 100644 --- a/ostd/unordered_map.hh +++ b/ostd/unordered_map.hh @@ -36,13 +36,13 @@ inline std::unordered_map make_unordered_map( E const &kequal = E{}, A const &alloc = A{} ) { static_assert( - detail::is_2tuple_like>, + detail::is_2tuple_like>, "the range element must be a pair/2-tuple" ); using MP = std::pair; - using AK = std::tuple_element_t<0, RangeValue>; - using AV = std::tuple_element_t<1, RangeValue>; + using AK = std::tuple_element_t<0, range_value_t>; + using AV = std::tuple_element_t<1, range_value_t>; static_assert( std::is_constructible_v && std::is_constructible_v, @@ -51,21 +51,21 @@ inline std::unordered_map make_unordered_map( std::unordered_map ret{bcount, hash, kequal, alloc}; - using C = RangeCategory; - if constexpr(std::is_convertible_v) { + using C = range_category_t; + if constexpr(std::is_convertible_v) { /* at least try to preallocate here... */ ret.reserve(range.size()); } for (; !range.empty(); range.pop_front()) { - if constexpr(std::is_constructible_v>) { + if constexpr(std::is_constructible_v>) { ret.emplace(range.front()); } else { /* store a temporary to prevent calling front() twice; however, * for values that can be used to construct the pair directly * we can just do the above */ - RangeValue v{range.front()}; + range_value_t v{range.front()}; ret.emplace(std::move(std::get<0>(v)), std::move(std::get<1>(v))); } } @@ -74,27 +74,27 @@ inline std::unordered_map make_unordered_map( template< typename R, - typename H = std::hash::first_type>, - typename E = std::equal_to::first_type>, + typename H = std::hash::first_type>, + typename E = std::equal_to::first_type>, typename A = std::allocator>, - std::tuple_element_t<1, RangeValue> + std::tuple_element_t<0, range_value_t>, + std::tuple_element_t<1, range_value_t> >> > inline std::unordered_map< - std::tuple_element_t<0, RangeValue>, - std::tuple_element_t<1, RangeValue>, H, E, A + std::tuple_element_t<0, range_value_t>, + std::tuple_element_t<1, range_value_t>, H, E, A > make_unordered_map( R &&range, size_t bcount = 1, H const &hash = H{}, E const &kequal = E{}, A const &alloc = A{} ) { static_assert( - detail::is_2tuple_like>, + detail::is_2tuple_like>, "the range element must be a pair/2-tuple" ); return make_unordered_map< - std::tuple_element_t<0, RangeValue>, - std::tuple_element_t<1, RangeValue>, H, E, A + std::tuple_element_t<0, range_value_t>, + std::tuple_element_t<1, range_value_t>, H, E, A >(std::forward(range), bcount, hash, kequal, alloc); } diff --git a/ostd/vector.hh b/ostd/vector.hh index f393ca1..d18c731 100644 --- a/ostd/vector.hh +++ b/ostd/vector.hh @@ -17,8 +17,8 @@ namespace ostd { template, typename R> inline std::vector make_vector(R range, A const &alloc = A{}) { std::vector ret{alloc}; - using C = RangeCategory; - if constexpr(std::is_convertible_v) { + using C = range_category_t; + if constexpr(std::is_convertible_v) { /* finite random access or contiguous */ auto h = range.half(); ret.reserve(range.size()); @@ -32,11 +32,11 @@ inline std::vector make_vector(R range, A const &alloc = A{}) { return ret; } -template>> -inline std::vector, A> make_vector( +template>> +inline std::vector, A> make_vector( R &&range, A const &alloc = A{} ) { - return make_vector, A>(std::forward(range), alloc); + return make_vector, A>(std::forward(range), alloc); } } /* namespace ostd */