timur/snipplib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2026-06-23 12:44:12 +03:00
parent 44add664d3
commit 97ad939095
3 changed files with 173 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
examples/str_exam.cpp
View File

@@ -24,6 +24,24 @@ int main()
std::println("sv(TrimType::TRIM_BOTH) = '{}'", sv);
si = "123; we; d34534; ";
std::vector<std::string_view> rv;
rv = snplib_split_char_range<decltype(rv)>(si, "; ");
std::println("\n\nstr = '{}'", si);
std::println("all elems: ");
for (auto& el : rv) {
std::println("el = '{}'", el);
}
rv = snplib_split_char_range<decltype(rv)>(si, "; ", 1, 2);
std::println("2 elems starting from 1: ");
for (auto& el : rv) {
std::println("el = '{}'", el);
}
return 0;
}

86
include/snipplib/utils/snplib_keyvalue.h
View File

@@ -15,6 +15,8 @@ class snplib_keyvalue_t
{
public:
static constexpr bool mutableContent = snplib_output_char_range_c<ByteSeqT>;
static constexpr bool stringViewContent =
std::ranges::viewable_range<ByteSeqT> && std::ranges::contiguous_range<ByteSeqT>;
typedef std::error_code error_t;
@@ -32,8 +34,73 @@ public:
template <snplib_char_range_c R>
requires mutableContent
error_t fromByteSequence(R&& r)
error_t fromByteSequence(R&& bytes)
{
// key and value
if constexpr (stringViewContent) {
auto bs = snplib_trim_spaces_as_view(bytes, TrimType::TRIM_LEFT);
auto found = std::ranges::search(bs, _config.keyval_delim);
if (found.empty()) { // no value
_key = snplib_trim_spaces_as_view(bs, TrimType::TRIM_RIGHT);
_value = std::string_view();
} else {
_key = snplib_trim_spaces_as_view(std::string_view(bs.begin(), found.begin()), TrimType::TRIM_RIGHT);
// do not delete space at the end of value-string!
_value = std::string_view(found.end(), bs.end());
}
} else if constexpr (std::ranges::viewable_range<R>) {
auto bs = bytes | std::views::drop_while(snplib_is_space);
auto found = std::ranges::search(bs, _config.keyval_delim);
_value.clear();
if (found.empty()) { // no value
_key = snplib_trim_spaces(bs, TrimType::TRIM_RIGHT);
} else {
_key.clear();
auto N = std::ranges::distance(bs.begin(), found.begin());
std::ranges::copy(std::views::all(bs) | std::views::take(N) | std::views::reverse |
std::views::drop_while(snplib_is_space),
std::back_inserter(_key));
std::ranges::copy(found.end(), bs.end(), std::back_inserter(_value));
}
} else { // always coping
auto bs = snplib_trim_spaces(bytes, TrimType::TRIM_LEFT);
auto found = std::ranges::search(bs, _config.keyval_delim);
_value.clear();
if (found.empty()) { // no value
_key = snplib_trim_spaces(bs, TrimType::TRIM_RIGHT);
} else {
_key.clear;
auto N = std::ranges::distance(bs.begin(), found.begin());
// std::ranges::copy_n(bs.begin(), N, std::back_inserter(_key));
size_t i = 0;
for (auto it = bs.begin(); it != found.begin(); ++it, ++i) {
if (i < N) {
if (!snplib_is_space(*it)) {
std::back_inserter(_key) = *it;
}
}
}
}
std::ranges::copy(found.end(), bs.end(), std::back_inserter(_value));
}
// split value to elements
if (_value.size()) {
_valueSeq = snplib_split_char_range<decltype(_valueSeq)>(_value, _config.valseq_delim);
}
}
template <snplib_char_range_c R>
@@ -72,9 +139,20 @@ public:
}
protected:
std::conditional_t<mutableContent, std::string, std::string_view> _key;
std::conditional_t<mutableContent, std::string, std::string_view> _value;
std::conditional_t<mutableContent, std::vector<std::string>, std::vector<std::string_view>> _valueSeq;
std::
conditional_t<mutableContent, std::string, std::conditional_t<stringViewContent, std::string_view, std::string>>
_key;
std::
conditional_t<mutableContent, std::string, std::conditional_t<stringViewContent, std::string_view, std::string>>
_value;
std::vector<std::string_view> _valueSeq;
// std::conditional_t<mutableContent,
// std::vector<std::string>,
// std::conditional_t<stringViewContent, std::vector<std::string_view>,
// std::vector<std::string>>>
// _valueSeq;
config_t _config;
};
} // namespace snplib

72
include/snipplib/utils/snplib_string.h
View File

@@ -105,6 +105,9 @@ static constexpr bool snplib_char_ranges_compare(R1&& what, R2&& where, bool cas
}
//
// or_ctor_args - to use with non-default-constructible classes (or just for non-default constructors)
//
template <snplib_char_range_c OR, snplib_char_range_c IR, typename... CTorTs>
static constexpr OR snplib_transform_char_range(IR&& r, CTorTs&&... or_ctor_args)
{
@@ -122,6 +125,75 @@ static constexpr OR snplib_transform_char_range(IR&& r, CTorTs&&... or_ctor_args
}
}
template <std::ranges::range OR, snplib_input_char_range_c IR, snplib_input_char_range_c DR>
static constexpr OR snplib_split_char_range(IR&& input,
DR&& delim,
size_t start = 0,
size_t N = std::numeric_limits<size_t>::max())
requires(std::ranges::output_range<OR, std::ranges::range_value_t<OR>> && !std::ranges::borrowed_range<OR> &&
snplib_view_or_output_char_range_c<std::ranges::range_value_t<OR>>)
{
static_assert(
snplib_char_view_c<std::ranges::range_value_t<OR>> && std::ranges::viewable_range<std::remove_cvref_t<IR>>,
"Incompatible input and output types!");
if constexpr (std::is_pointer_v<std::decay_t<DR>>) { // char*, const char*, char[]
return snplib_split_char_range<OR>(std::forward<IR>(input), std::string_view(delim), start, N);
} else {
OR res;
if (!N) {
return res;
}
auto dlim_sz = std::ranges::size(delim);
size_t curr_idx = 0, last_idx = start + N - 1;
using el_t = std::ranges::range_value_t<OR>;
using it_t = std::ranges::iterator_t<IR>;
static_assert(std::constructible_from<el_t, it_t, it_t>,
"Incompatible input and output types: cannot create element!");
auto it = input.begin();
std::vector<it_t> delim_it;
do {
it = std::search(it, input.end(), delim.begin(), delim.end());
delim_it.emplace_back(it);
if (it == input.end()) {
break;
}
std::advance(it, dlim_sz);
if (++curr_idx > last_idx) {
break;
}
} while (true);
it = input.begin();
curr_idx = 0;
for (auto const& iter : delim_it) {
if (curr_idx >= start) {
std::back_inserter(res) = el_t(it, iter);
}
std::advance(it = iter, dlim_sz);
++curr_idx;
}
return res;
}
}
template <typename T, snplib_input_char_range_c R>
static std::optional<T> snplib_num_from_range(R&& r)
requires((std::integral<T> || std::floating_point<T>) && std::ranges::contiguous_range<R>)