2017-01-29 23:54:06 +00:00
|
|
|
/* String utilities for OctaSTD.
|
2015-05-27 20:43:13 +00:00
|
|
|
*
|
|
|
|
* This file is part of OctaSTD. See COPYING.md for futher information.
|
|
|
|
*/
|
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#ifndef OSTD_STRING_HH
|
|
|
|
#define OSTD_STRING_HH
|
2015-05-27 20:43:13 +00:00
|
|
|
|
2015-05-27 21:15:24 +00:00
|
|
|
#include <stdio.h>
|
2015-05-27 20:43:13 +00:00
|
|
|
#include <stddef.h>
|
2016-09-01 23:06:13 +00:00
|
|
|
#include <ctype.h>
|
2015-05-27 20:43:13 +00:00
|
|
|
|
2017-01-29 20:22:40 +00:00
|
|
|
#include <string>
|
|
|
|
#include <string_view>
|
2017-02-01 19:56:19 +00:00
|
|
|
#include <type_traits>
|
2017-02-08 00:06:50 +00:00
|
|
|
#include <functional>
|
2017-02-16 19:39:05 +00:00
|
|
|
#include <utility>
|
2017-01-29 20:22:40 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#include "ostd/range.hh"
|
|
|
|
#include "ostd/vector.hh"
|
2017-01-25 00:44:22 +00:00
|
|
|
#include "ostd/algorithm.hh"
|
2015-05-27 20:43:13 +00:00
|
|
|
|
2015-07-13 19:07:14 +00:00
|
|
|
namespace ostd {
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2017-02-12 22:02:49 +00:00
|
|
|
template<typename T, typename TR = std::char_traits<std::remove_const_t<T>>>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct basic_char_range: input_range<basic_char_range<T>> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using range_category = contiguous_range_tag;
|
2017-02-16 19:02:55 +00:00
|
|
|
using value_type = T;
|
|
|
|
using reference = T &;
|
|
|
|
using size_type = size_t;
|
|
|
|
using difference_type = ptrdiff_t;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-07-21 20:16:38 +00:00
|
|
|
private:
|
2017-02-17 16:50:44 +00:00
|
|
|
struct nat {};
|
2015-07-21 20:16:38 +00:00
|
|
|
|
|
|
|
public:
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range(): p_beg(nullptr), p_end(nullptr) {};
|
|
|
|
basic_char_range(T *beg, T *end): p_beg(beg), p_end(end) {}
|
|
|
|
basic_char_range(std::nullptr_t): p_beg(nullptr), p_end(nullptr) {}
|
2015-08-06 23:08:59 +00:00
|
|
|
|
2017-02-17 16:50:44 +00:00
|
|
|
template<typename U>
|
|
|
|
basic_char_range(U &&beg, std::enable_if_t<
|
|
|
|
std::is_convertible_v<U, T *>, nat
|
|
|
|
> = nat{}): p_beg(beg) {
|
|
|
|
if constexpr(std::is_array_v<std::remove_reference_t<U>>) {
|
|
|
|
size_t N = std::extent_v<std::remove_reference_t<U>>;
|
|
|
|
p_end = beg + N - (beg[N - 1] == '\0');
|
|
|
|
} else {
|
|
|
|
p_end = beg + (beg ? TR::length(beg) : 0);
|
|
|
|
}
|
|
|
|
}
|
2015-07-01 19:09:02 +00:00
|
|
|
|
2017-02-09 20:39:03 +00:00
|
|
|
template<typename STR, typename A>
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range(std::basic_string<std::remove_const_t<T>, STR, A> const &s):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_beg(s.data()), p_end(s.data() + s.size())
|
|
|
|
{}
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2017-02-17 16:50:44 +00:00
|
|
|
template<typename U, typename TTR, typename = std::enable_if_t<
|
2017-02-09 19:56:15 +00:00
|
|
|
std::is_convertible_v<U *, T *>
|
|
|
|
>>
|
2017-02-17 16:50:44 +00:00
|
|
|
basic_char_range(basic_char_range<U, TTR> const &v):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_beg(&v[0]), p_end(&v[v.size()])
|
|
|
|
{}
|
2015-06-17 01:00:39 +00:00
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range &operator=(basic_char_range const &v) {
|
2015-06-09 17:59:25 +00:00
|
|
|
p_beg = v.p_beg; p_end = v.p_end; return *this;
|
|
|
|
}
|
2015-07-01 19:09:02 +00:00
|
|
|
|
2017-02-09 20:39:03 +00:00
|
|
|
template<typename STR, typename A>
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range &operator=(std::basic_string<T, STR, A> const &s) {
|
2015-06-09 17:59:25 +00:00
|
|
|
p_beg = s.data(); p_end = s.data() + s.size(); return *this;
|
|
|
|
}
|
2017-02-09 20:39:03 +00:00
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range &operator=(T *s) {
|
2017-02-09 20:39:03 +00:00
|
|
|
p_beg = s; p_end = s + (s ? TR::length(s) : 0); return *this;
|
2015-06-09 17:59:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const { return p_beg == p_end; }
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
2015-06-09 17:59:25 +00:00
|
|
|
++p_beg;
|
2017-02-19 15:45:06 +00:00
|
|
|
if (p_beg > p_end) {
|
|
|
|
throw std::out_of_range{"pop_front on empty range"};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void push_front() {
|
|
|
|
--p_beg;
|
2015-06-09 17:59:25 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_t n) {
|
2015-06-09 17:59:25 +00:00
|
|
|
p_beg += n;
|
|
|
|
if (p_beg > p_end) {
|
2017-02-19 15:45:06 +00:00
|
|
|
throw std::out_of_range{"pop_front_n of too many elements"};
|
2015-06-09 17:59:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(size_t n) {
|
|
|
|
p_beg -= n;
|
|
|
|
}
|
2015-06-09 17:59:25 +00:00
|
|
|
|
|
|
|
T &front() const { return *p_beg; }
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
bool equals_front(basic_char_range const &range) const {
|
2015-06-09 17:59:25 +00:00
|
|
|
return p_beg == range.p_beg;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
ptrdiff_t distance_front(basic_char_range const &range) const {
|
2015-06-09 17:59:25 +00:00
|
|
|
return range.p_beg - p_beg;
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (p_end == p_beg) {
|
2017-02-19 15:45:06 +00:00
|
|
|
return;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-06-09 17:59:25 +00:00
|
|
|
--p_end;
|
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back() {
|
|
|
|
++p_end;
|
|
|
|
}
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back_n(size_t n) {
|
2015-06-09 17:59:25 +00:00
|
|
|
p_end -= n;
|
|
|
|
if (p_end < p_beg) {
|
2017-02-19 15:45:06 +00:00
|
|
|
throw std::out_of_range{"pop_back_n of too many elements"};
|
2015-06-09 17:59:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back_n(size_t n) {
|
|
|
|
p_end += n;
|
|
|
|
}
|
2015-06-09 17:59:25 +00:00
|
|
|
|
|
|
|
T &back() const { return *(p_end - 1); }
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
bool equals_back(basic_char_range const &range) const {
|
2015-06-09 17:59:25 +00:00
|
|
|
return p_end == range.p_end;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
ptrdiff_t distance_back(basic_char_range const &range) const {
|
2015-06-09 17:59:25 +00:00
|
|
|
return range.p_end - p_end;
|
|
|
|
}
|
|
|
|
|
2017-01-30 18:11:39 +00:00
|
|
|
size_t size() const { return p_end - p_beg; }
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
basic_char_range slice(size_t start, size_t end) const {
|
|
|
|
return basic_char_range(p_beg + start, p_beg + end);
|
2015-06-09 17:59:25 +00:00
|
|
|
}
|
|
|
|
|
2017-01-30 18:11:39 +00:00
|
|
|
T &operator[](size_t i) const { return p_beg[i]; }
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(T v) {
|
2017-02-19 17:31:08 +00:00
|
|
|
if (p_beg == p_end) {
|
|
|
|
throw std::out_of_range{"put into an empty range"};
|
|
|
|
}
|
2015-06-09 17:59:25 +00:00
|
|
|
*(p_beg++) = v;
|
|
|
|
}
|
|
|
|
|
|
|
|
T *data() { return p_beg; }
|
2016-06-23 18:18:35 +00:00
|
|
|
T const *data() const { return p_beg; }
|
2015-06-09 17:59:25 +00:00
|
|
|
|
2015-07-24 18:43:39 +00:00
|
|
|
/* non-range */
|
2017-02-16 17:48:14 +00:00
|
|
|
int compare(basic_char_range<T const> s) const {
|
2017-01-30 18:11:39 +00:00
|
|
|
size_t s1 = size(), s2 = s.size();
|
2016-08-17 23:34:20 +00:00
|
|
|
int ret;
|
2016-08-17 17:18:12 +00:00
|
|
|
if (!s1 || !s2) {
|
2016-08-17 23:34:20 +00:00
|
|
|
goto diffsize;
|
2016-08-17 17:18:12 +00:00
|
|
|
}
|
2017-02-18 16:54:51 +00:00
|
|
|
if ((ret = TR::compare(data(), s.data(), std::min(s1, s2)))) {
|
2016-08-17 23:34:20 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
diffsize:
|
|
|
|
return (s1 < s2) ? -1 : ((s1 > s2) ? 1 : 0);
|
2015-07-24 18:43:39 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
int case_compare(basic_char_range<T const> s) const {
|
2017-01-30 18:11:39 +00:00
|
|
|
size_t s1 = size(), s2 = s.size();
|
2017-02-18 16:54:51 +00:00
|
|
|
for (size_t i = 0, ms = std::min(s1, s2); i < ms; ++i) {
|
2016-09-01 23:06:13 +00:00
|
|
|
int d = toupper(p_beg[i]) - toupper(s[i]);
|
|
|
|
if (d) {
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (s1 < s2) ? -1 : ((s1 > s2) ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
2017-01-29 20:22:40 +00:00
|
|
|
/* that way we can assign, append etc to std::string */
|
2017-02-09 19:56:15 +00:00
|
|
|
operator std::basic_string_view<std::remove_cv_t<T>>() const {
|
|
|
|
return std::basic_string_view<std::remove_cv_t<T>>{data(), size()};
|
2017-01-29 20:22:40 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 17:59:25 +00:00
|
|
|
private:
|
|
|
|
T *p_beg, *p_end;
|
|
|
|
};
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
using char_range = basic_char_range<char>;
|
|
|
|
using string_range = basic_char_range<char const>;
|
2015-07-24 18:43:39 +00:00
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
/* comparisons between ranges */
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator==(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return !lhs.compare(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator!=(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return lhs.compare(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return lhs.compare(rhs) < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return lhs.compare(rhs) > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<=(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return lhs.compare(rhs) <= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>=(
|
|
|
|
basic_char_range<T, TR> lhs, basic_char_range<T, TR> rhs
|
|
|
|
) {
|
|
|
|
return lhs.compare(rhs) >= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* comparisons between mutable ranges and char arrays */
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator==(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return !lhs.compare(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator!=(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return lhs.compare(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return lhs.compare(rhs) < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return lhs.compare(rhs) > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<=(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return lhs.compare(rhs) <= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>=(basic_char_range<T, TR> lhs, T const *rhs) {
|
|
|
|
return lhs.compare(rhs) >= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator==(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return !rhs.compare(lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator!=(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return rhs.compare(lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<=(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) >= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>=(T const *lhs, basic_char_range<T, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) <= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* comparisons between immutable ranges and char arrays */
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator==(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-24 18:43:39 +00:00
|
|
|
return !lhs.compare(rhs);
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator!=(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-25 01:34:07 +00:00
|
|
|
return lhs.compare(rhs);
|
2015-07-24 18:43:39 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-24 18:43:39 +00:00
|
|
|
return lhs.compare(rhs) < 0;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-24 18:43:39 +00:00
|
|
|
return lhs.compare(rhs) > 0;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<=(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-24 18:43:39 +00:00
|
|
|
return lhs.compare(rhs) <= 0;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>=(basic_char_range<T const, TR> lhs, T const *rhs) {
|
2015-07-24 18:43:39 +00:00
|
|
|
return lhs.compare(rhs) >= 0;
|
|
|
|
}
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator==(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return !rhs.compare(lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator!=(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return rhs.compare(lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator<=(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) >= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename TR>
|
|
|
|
inline bool operator>=(T const *lhs, basic_char_range<T const, TR> rhs) {
|
|
|
|
return rhs.compare(lhs) <= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool starts_with(string_range a, string_range b
|
|
|
|
) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (a.size() < b.size()) {
|
2015-12-31 15:36:41 +00:00
|
|
|
return false;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-12-31 15:36:41 +00:00
|
|
|
return a.slice(0, b.size()) == b;
|
|
|
|
}
|
|
|
|
|
2017-02-01 19:56:19 +00:00
|
|
|
template<typename T, typename TR, typename A>
|
|
|
|
struct ranged_traits<std::basic_string<T, TR, A>> {
|
2017-02-16 17:48:14 +00:00
|
|
|
using range = basic_char_range<T, TR>;
|
2017-02-15 18:13:52 +00:00
|
|
|
|
|
|
|
static range iter(std::basic_string<T, TR, A> &v) {
|
|
|
|
return range{v.data(), v.data() + v.size()};
|
2017-01-29 20:22:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-02-01 19:56:19 +00:00
|
|
|
template<typename T, typename TR, typename A>
|
|
|
|
struct ranged_traits<std::basic_string<T, TR, A> const> {
|
2017-02-16 17:48:14 +00:00
|
|
|
using range = basic_char_range<T const, TR>;
|
2017-02-15 18:13:52 +00:00
|
|
|
|
|
|
|
static range iter(std::basic_string<T, TR, A> const &v) {
|
|
|
|
return range{v.data(), v.data() + v.size()};
|
2017-01-29 20:22:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-02-01 19:56:19 +00:00
|
|
|
template<
|
|
|
|
typename T, typename TR = std::char_traits<T>,
|
|
|
|
typename A = std::allocator<T>, typename R
|
|
|
|
>
|
|
|
|
inline std::basic_string<T, TR, A> make_string(R range, A const &alloc = A{}) {
|
|
|
|
std::basic_string<T, TR, A> ret{alloc};
|
2017-02-16 19:02:55 +00:00
|
|
|
using C = range_category_t<R>;
|
|
|
|
if constexpr(std::is_convertible_v<C, finite_random_access_range_tag>) {
|
2017-02-01 19:56:19 +00:00
|
|
|
/* finite random access or contiguous */
|
|
|
|
auto h = range.half();
|
|
|
|
ret.reserve(range.size());
|
|
|
|
ret.insert(ret.end(), h, h + range.size());
|
|
|
|
} else {
|
|
|
|
/* infinite random access and below */
|
|
|
|
for (; !range.empty(); range.pop_front()) {
|
|
|
|
ret.push_back(range.front());
|
|
|
|
}
|
2015-07-12 02:11:05 +00:00
|
|
|
}
|
2017-01-29 23:54:06 +00:00
|
|
|
return ret;
|
2017-01-29 14:56:02 +00:00
|
|
|
}
|
|
|
|
|
2017-02-01 19:56:19 +00:00
|
|
|
template<
|
2017-02-16 19:02:55 +00:00
|
|
|
typename R, typename TR = std::char_traits<std::remove_cv_t<range_value_t<R>>>,
|
|
|
|
typename A = std::allocator<std::remove_cv_t<range_value_t<R>>>
|
2017-02-01 19:56:19 +00:00
|
|
|
>
|
2017-02-16 19:02:55 +00:00
|
|
|
inline std::basic_string<std::remove_cv_t<range_value_t<R>>, TR, A> make_string(
|
2017-02-01 19:56:19 +00:00
|
|
|
R range, A const &alloc = A{}
|
|
|
|
) {
|
2017-02-16 19:02:55 +00:00
|
|
|
return make_string<std::remove_cv_t<range_value_t<R>>, TR, A>(
|
2017-02-09 19:56:15 +00:00
|
|
|
std::move(range), alloc
|
|
|
|
);
|
2017-01-29 23:54:06 +00:00
|
|
|
}
|
2015-06-03 22:07:57 +00:00
|
|
|
|
2015-07-18 00:02:13 +00:00
|
|
|
/* string literals */
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
inline namespace literals {
|
|
|
|
inline namespace string_literals {
|
2017-02-16 17:48:14 +00:00
|
|
|
inline string_range operator "" _sr(char const *str, size_t len) {
|
|
|
|
return string_range(str, str + len);
|
2015-07-21 23:13:44 +00:00
|
|
|
}
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
|
|
|
}
|
2015-07-18 00:02:13 +00:00
|
|
|
|
2016-03-21 21:21:41 +00:00
|
|
|
template<typename R>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct temp_c_string {
|
2016-03-19 19:52:46 +00:00
|
|
|
private:
|
2017-02-16 19:02:55 +00:00
|
|
|
std::remove_cv_t<range_value_t<R>> *p_buf;
|
2016-03-19 19:52:46 +00:00
|
|
|
bool p_allocated;
|
|
|
|
|
|
|
|
public:
|
2017-02-16 19:39:05 +00:00
|
|
|
temp_c_string() = delete;
|
|
|
|
temp_c_string(temp_c_string const &) = delete;
|
|
|
|
temp_c_string(temp_c_string &&s): p_buf(s.p_buf), p_allocated(s.p_allocated) {
|
2016-03-19 19:52:46 +00:00
|
|
|
s.p_buf = nullptr;
|
|
|
|
s.p_allocated = false;
|
|
|
|
}
|
2017-02-16 19:39:05 +00:00
|
|
|
temp_c_string(R input, std::remove_cv_t<range_value_t<R>> *sbuf, size_t bufsize)
|
2016-03-19 19:52:46 +00:00
|
|
|
: p_buf(nullptr), p_allocated(false) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (input.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
2016-03-19 19:52:46 +00:00
|
|
|
if (input.size() >= bufsize) {
|
2017-02-16 19:02:55 +00:00
|
|
|
p_buf = new std::remove_cv_t<range_value_t<R>>[input.size() + 1];
|
2016-03-19 19:52:46 +00:00
|
|
|
p_allocated = true;
|
2016-07-31 19:40:25 +00:00
|
|
|
} else {
|
|
|
|
p_buf = sbuf;
|
|
|
|
}
|
2017-02-20 17:04:03 +00:00
|
|
|
char_range bufr{p_buf, p_buf + input.size() + 1};
|
2017-02-19 17:14:09 +00:00
|
|
|
range_put_all(bufr, input);
|
|
|
|
bufr.put('\0');
|
2016-03-19 19:52:46 +00:00
|
|
|
}
|
2017-02-16 19:39:05 +00:00
|
|
|
~temp_c_string() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (p_allocated) {
|
|
|
|
delete[] p_buf;
|
|
|
|
}
|
2016-03-19 19:52:46 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
temp_c_string &operator=(temp_c_string const &) = delete;
|
|
|
|
temp_c_string &operator=(temp_c_string &&s) {
|
2016-03-19 19:52:46 +00:00
|
|
|
swap(s);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
operator std::remove_cv_t<range_value_t<R>> const *() const { return p_buf; }
|
|
|
|
std::remove_cv_t<range_value_t<R>> const *get() const { return p_buf; }
|
2016-03-19 19:52:46 +00:00
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
void swap(temp_c_string &s) {
|
2017-01-29 14:56:02 +00:00
|
|
|
using std::swap;
|
|
|
|
swap(p_buf, s.p_buf);
|
|
|
|
swap(p_allocated, s.p_allocated);
|
2016-03-19 19:52:46 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-01-29 14:56:02 +00:00
|
|
|
template<typename R>
|
2017-02-16 19:39:05 +00:00
|
|
|
inline void swap(temp_c_string<R> &a, temp_c_string<R> &b) {
|
2017-01-29 14:56:02 +00:00
|
|
|
a.swap(b);
|
|
|
|
}
|
|
|
|
|
2016-03-21 21:21:41 +00:00
|
|
|
template<typename R>
|
2017-02-16 19:39:05 +00:00
|
|
|
inline temp_c_string<R> to_temp_cstr(
|
2017-02-16 19:02:55 +00:00
|
|
|
R input, std::remove_cv_t<range_value_t<R>> *buf, size_t bufsize
|
2016-07-31 19:40:25 +00:00
|
|
|
) {
|
2017-02-16 19:39:05 +00:00
|
|
|
return temp_c_string<R>(input, buf, bufsize);
|
2016-03-19 19:52:46 +00:00
|
|
|
}
|
|
|
|
|
2015-07-13 19:07:14 +00:00
|
|
|
} /* namespace ostd */
|
2015-06-03 22:07:57 +00:00
|
|
|
|
2017-01-29 20:22:40 +00:00
|
|
|
namespace std {
|
|
|
|
|
2017-02-16 17:48:14 +00:00
|
|
|
template<typename T, typename TR>
|
|
|
|
struct hash<ostd::basic_char_range<T, TR>> {
|
|
|
|
size_t operator()(ostd::basic_char_range<T, TR> const &v) const {
|
|
|
|
return hash<std::basic_string_view<std::remove_const_t<T>, TR>>{}(v);
|
2017-01-29 20:22:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-02-07 21:17:15 +00:00
|
|
|
#endif
|