768 lines
23 KiB
C++
768 lines
23 KiB
C++
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <charconv>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <mutex>
|
|
#include <ranges>
|
|
#include <regex>
|
|
#include <thread>
|
|
#include <utility>
|
|
|
|
#include "../common/adc_traits.h"
|
|
|
|
|
|
namespace adc::utils
|
|
{
|
|
|
|
// compile-time size of zero-terminated char array
|
|
static consteval size_t AdcCharArrSize(const char* arr)
|
|
{
|
|
return *arr ? 1 + AdcCharArrSize(arr + 1) : 0;
|
|
}
|
|
|
|
static bool AdcIsSpace(char in) noexcept
|
|
{
|
|
static constexpr auto ws = {' ', '\t', '\n', '\v', '\r', '\f'};
|
|
return std::ranges::any_of(ws, [in](auto p) { return p == in; });
|
|
};
|
|
|
|
|
|
template <traits::adc_char_range R>
|
|
static auto AdcTrimSpaces(R&& r)
|
|
{
|
|
return r | std::views::drop_while(AdcIsSpace) | std::views::reverse | std::views::drop_while(AdcIsSpace) |
|
|
std::views::reverse;
|
|
}
|
|
|
|
|
|
enum class AdcTrimType { TRIM_LEFT, TRIM_RIGHT, TRIM_BOTH };
|
|
|
|
template <traits::adc_char_view VR, traits::adc_char_range R>
|
|
requires std::ranges::contiguous_range<R>
|
|
static auto AdcTrimSpacesView(R&& r, AdcTrimType type = AdcTrimType::TRIM_BOTH)
|
|
{
|
|
auto is_space = [](const auto& ch) { return ch == ' '; };
|
|
|
|
auto end = std::forward<R>(r).end();
|
|
|
|
auto f1 = std::forward<R>(r).begin();
|
|
|
|
if (type != AdcTrimType::TRIM_RIGHT) {
|
|
// look for the first non-space symbol
|
|
f1 = std::ranges::find_if_not(std::forward<R>(r), is_space);
|
|
if (f1 == end) { // all are spaces!
|
|
return VR();
|
|
}
|
|
}
|
|
|
|
auto f2 = end;
|
|
|
|
if (type != AdcTrimType::TRIM_LEFT) {
|
|
auto f3 = f1;
|
|
|
|
do {
|
|
f2 = std::ranges::find_if(++f3, end, is_space);
|
|
if (f2 == end)
|
|
break;
|
|
f3 = std::ranges::find_if_not(f2 + 1, end, is_space);
|
|
} while (f3 != end);
|
|
}
|
|
|
|
return VR(f1, f2);
|
|
}
|
|
|
|
template <traits::adc_char_range R>
|
|
static auto AdcTrimSpacesView(R&& r, AdcTrimType type = AdcTrimType::TRIM_BOTH)
|
|
{
|
|
return AdcTrimSpacesView<std::string_view>(std::forward<R>(r), type);
|
|
}
|
|
|
|
|
|
template <typename ValueT, traits::adc_char_range R>
|
|
static ValueT AdcFromChars(R&& range)
|
|
{
|
|
using v_t = std::remove_cv_t<ValueT>;
|
|
|
|
|
|
#ifdef _LIBCPP_VERSION // clang's libc++ does not have floating-point overloads for std::from_chars
|
|
if constexpr (traits::adc_is_any_v<v_t, char, int, long, long long, __int128>) {
|
|
#else
|
|
if constexpr (traits::adc_is_any_of_v<v_t, unsigned char, char, unsigned short, short, unsigned long, long,
|
|
unsigned long long, long long, unsigned int, int, unsigned __int128, __int128,
|
|
float, double, long double>) {
|
|
#endif
|
|
v_t v;
|
|
|
|
auto rr = AdcTrimSpaces(range);
|
|
|
|
std::from_chars_result res;
|
|
const char* end_ptr;
|
|
|
|
// std::from_chars needs random-access container!!!
|
|
if constexpr (std::ranges::random_access_range<R>) {
|
|
res = std::from_chars(&*rr.begin(), &*rr.end(), v);
|
|
end_ptr = &*rr.end();
|
|
} else {
|
|
std::string s(rr.begin(), rr.end());
|
|
end_ptr = s.data() + s.size();
|
|
res = std::from_chars(s.data(), s.data() + s.size(), v);
|
|
}
|
|
|
|
if (res.ec == std::errc()) {
|
|
if (res.ptr != end_ptr) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
|
|
}
|
|
|
|
return v;
|
|
} else if (res.ec == std::errc::invalid_argument) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
|
|
} else if (res.ec == std::errc::result_out_of_range) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (result out of range)");
|
|
}
|
|
#ifdef _LIBCPP_VERSION // clang's libc++ does not have floating-point overloads for std::from_chars
|
|
} else if constexpr (std::is_floating_point_v<v_t>) {
|
|
v_t v;
|
|
|
|
auto rr = AdcTrimSpaces(range);
|
|
|
|
std::string s(rr.begin(), rr.end());
|
|
size_t pos;
|
|
try {
|
|
if constexpr (std::is_same_v<v_t, float>) {
|
|
v = std::stof(s, &pos);
|
|
} else if constexpr (std::is_same_v<v_t, double>) {
|
|
v = std::stod(s, &pos);
|
|
} else if constexpr (std::is_same_v<v_t, long double>) {
|
|
v = std::stold(s, &pos);
|
|
}
|
|
} catch (const std::invalid_argument&) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
|
|
} catch (const std::out_of_range&) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (result out of range)");
|
|
}
|
|
|
|
if (pos != s.size()) {
|
|
throw std::invalid_argument(
|
|
"AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
|
|
}
|
|
|
|
return v;
|
|
#endif
|
|
} else if constexpr (std::is_constructible_v<ValueT, std::ranges::iterator_t<R>, std::ranges::iterator_t<R>>) {
|
|
return ValueT(range.begin(), range.end());
|
|
} else {
|
|
static_assert(false,
|
|
"AdcFromChars: CANNOT CONVERT CHAR-RANGE TO USER-TYPE VALUE (UNSUPPORTED USER-VALUE TYPE)");
|
|
// throw std::invalid_argument(
|
|
// "AdcFromChars: cannot convert char-range to user-type value (unsupported user-value type)");
|
|
}
|
|
|
|
return ValueT();
|
|
}
|
|
|
|
|
|
/* TRIVIAL SERIALIZER/DESERIALIZER */
|
|
|
|
static const std::regex AdcIntegerRegex("^ *[+-]?\\d+\\d* *$", std::regex::ECMAScript);
|
|
static const std::regex AdcRealRegex("^ *[-+]?\\d+\\d*\\.?\\d*([Ee][-+]?\\d+)? *$", std::regex::ECMAScript);
|
|
|
|
// template <typename SerializedT, traits::formattable VT>
|
|
template <typename SerializedT, typename VT>
|
|
static SerializedT AdcTrivialSerializer(VT&& value)
|
|
{
|
|
using v_t = std::decay_t<VT>;
|
|
|
|
if constexpr (std::is_convertible_v<v_t, SerializedT>) {
|
|
return static_cast<SerializedT>(std::forward<VT>(value));
|
|
} else if constexpr (traits::adc_output_char_range<SerializedT> && traits::adc_input_char_range<v_t>) {
|
|
SerializedT s_val;
|
|
std::ranges::copy(std::forward<VT>(value), std::back_inserter(s_val));
|
|
return s_val;
|
|
} else if constexpr (traits::adc_output_char_range<SerializedT> && traits::formattable<v_t>) {
|
|
SerializedT s_val;
|
|
std::format_to(std::back_inserter(s_val), "{}", std::forward<VT>(value));
|
|
return s_val;
|
|
} else {
|
|
// throw std::invalid_argument("trivial serializer: cannot serialize value");
|
|
static_assert(false, "TRIVIAL SERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
|
|
}
|
|
}
|
|
|
|
|
|
template <typename VT, typename SerializedT = std::string>
|
|
static VT AdcTrivialDeserializer(SerializedT&& s_value)
|
|
{
|
|
if constexpr (std::is_convertible_v<SerializedT, VT>) {
|
|
return static_cast<VT>(std::forward<SerializedT>(s_value));
|
|
} else if constexpr (traits::adc_input_char_range<SerializedT>) {
|
|
return AdcFromChars<VT>(std::forward<SerializedT>(s_value));
|
|
} else {
|
|
static_assert(false, "TRIVIAL DESERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
|
|
}
|
|
|
|
return VT();
|
|
}
|
|
|
|
|
|
template <std::ranges::range OutputR, traits::adc_input_char_range InputR, traits::adc_input_char_range DelimR>
|
|
static auto AdcValueRangeFromCharRange(OutputR& res,
|
|
InputR&& input_r,
|
|
DelimR&& delim,
|
|
size_t max_len = std::numeric_limits<size_t>::max())
|
|
{
|
|
if (max_len == 0) {
|
|
return res.begin();
|
|
}
|
|
|
|
using value_t = std::ranges::range_value_t<OutputR>;
|
|
|
|
if constexpr (std::is_array_v<std::remove_cvref_t<DelimR>>) {
|
|
std::ranges::copy(std::views::split(std::forward<InputR>(input_r), std::string_view(delim)) |
|
|
std::views::filter([](const auto& r) { return !std::ranges::empty(r); }) |
|
|
std::views::transform([](auto vl) { return AdcTrivialDeserializer<value_t>(vl); }) |
|
|
std::views::take(max_len),
|
|
std::back_inserter(res));
|
|
} else {
|
|
std::ranges::copy(std::views::split(std::forward<InputR>(input_r), std::forward<DelimR>(delim)) |
|
|
std::views::filter([](const auto& r) { return !std::ranges::empty(r); }) |
|
|
std::views::transform([](auto vl) { return AdcTrivialDeserializer<value_t>(vl); }) |
|
|
std::views::take(max_len),
|
|
std::back_inserter(res));
|
|
}
|
|
|
|
return res.begin();
|
|
}
|
|
|
|
|
|
template <traits::adc_output_char_range OutputR, std::ranges::range InputR, traits::adc_input_char_range DelimR>
|
|
static auto AdcCharRangeFromValueRange(OutputR& res,
|
|
InputR&& input_r,
|
|
DelimR&& delim,
|
|
size_t max_len = std::numeric_limits<size_t>::max())
|
|
{
|
|
max_len = max_len < std::ranges::size(input_r) ? max_len : std::ranges::size(input_r);
|
|
|
|
if (max_len == 0) {
|
|
return res.begin();
|
|
}
|
|
|
|
--max_len;
|
|
|
|
if (max_len) {
|
|
auto view = input_r | std::views::take(max_len) | std::views::transform([&delim](auto v) {
|
|
auto r = AdcTrivialSerializer<OutputR>(v);
|
|
std::ranges::copy(delim, std::back_inserter(r));
|
|
return r;
|
|
}) |
|
|
std::views::join;
|
|
|
|
std::ranges::copy(view, std::back_inserter(res));
|
|
|
|
auto view1 = input_r | std::views::drop(max_len) | std::views::take(1) | std::views::transform([](auto v) {
|
|
auto r = AdcTrivialSerializer<OutputR>(v);
|
|
return r;
|
|
}) |
|
|
std::views::join;
|
|
std::ranges::copy(view1, std::back_inserter(res));
|
|
} else {
|
|
res = AdcTrivialSerializer<OutputR>(*std::forward<InputR>(input_r).begin());
|
|
}
|
|
|
|
return res.begin();
|
|
}
|
|
|
|
|
|
namespace details
|
|
{
|
|
|
|
template <size_t I = 0, typename... Ts>
|
|
void setTupleElements(std::tuple<Ts...>& tp, auto&& r)
|
|
{
|
|
if (I < std::ranges::distance(r)) {
|
|
if constexpr (I < sizeof...(Ts)) {
|
|
std::get<I>(tp) =
|
|
AdcFromChars<std::tuple_element_t<I, std::tuple<Ts...>>>(*(r | std::views::drop(I)).begin());
|
|
|
|
setTupleElements<I + 1>(tp, std::forward<decltype(r)>(r));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
template <size_t I = 0, typename... Ts>
|
|
void fromTupleElements(const std::tuple<Ts...>& tp, auto& r, const auto& delim)
|
|
{
|
|
using r_t = std::decay_t<decltype(r)>;
|
|
|
|
if constexpr (I < (sizeof...(Ts) - 1)) {
|
|
auto el = AdcTrivialSerializer<r_t>(std::get<I>(tp));
|
|
std::ranges::copy(el, std::back_inserter(r));
|
|
std::ranges::copy(delim, std::back_inserter(r));
|
|
|
|
fromTupleElements<I + 1>(tp, r, delim);
|
|
} else if constexpr (I == (sizeof...(Ts) - 1)) {
|
|
auto el = AdcTrivialSerializer<r_t>(std::get<I>(tp));
|
|
std::ranges::copy(el, std::back_inserter(r));
|
|
}
|
|
}
|
|
|
|
} // namespace details
|
|
|
|
|
|
template <traits::adc_input_char_range InputR, traits::adc_input_char_range DelimR, typename... Ts>
|
|
static void AdcTupleFromCharRange(std::tuple<Ts...>& tp, InputR&& input_r, DelimR&& delim)
|
|
{
|
|
if constexpr (std::is_array_v<std::remove_cvref_t<DelimR>>) {
|
|
auto r = std::views::split(std::forward<InputR>(input_r), std::string_view(delim)) |
|
|
std::views::filter([](const auto& r) { return !std::ranges::empty(r); });
|
|
details::setTupleElements(tp, r);
|
|
} else {
|
|
auto r = std::views::split(std::forward<InputR>(input_r), std::forward<DelimR>(delim)) |
|
|
std::views::filter([](const auto& r) { return !std::ranges::empty(r); });
|
|
details::setTupleElements(tp, r);
|
|
}
|
|
}
|
|
|
|
|
|
template <traits::adc_output_char_range OutputR, traits::adc_input_char_range DelimR, typename... Ts>
|
|
static auto AdcCharRangeFromTuple(OutputR& res, const std::tuple<Ts...>& tp, DelimR&& delim)
|
|
{
|
|
if constexpr (sizeof...(Ts) > 1) {
|
|
details::fromTupleElements(tp, res, delim);
|
|
} else {
|
|
res = AdcTrivialSerializer<OutputR>(std::get<0>(tp));
|
|
}
|
|
|
|
return res.begin();
|
|
}
|
|
|
|
|
|
namespace details
|
|
{
|
|
|
|
template <typename DerivedT>
|
|
class AdcDelimiter
|
|
{
|
|
public:
|
|
template <traits::adc_input_char_range DT = std::string_view>
|
|
auto& setDelimiter(const DT& delimiter)
|
|
{
|
|
_delimiter = std::string{delimiter.begin(), delimiter.end()};
|
|
|
|
return static_cast<DerivedT&>(*this);
|
|
}
|
|
|
|
auto& setDelimiter(const char* delimiter)
|
|
{
|
|
_delimiter = std::string{delimiter};
|
|
|
|
return static_cast<DerivedT&>(*this);
|
|
}
|
|
|
|
protected:
|
|
template <traits::adc_input_char_range DT = std::string_view>
|
|
AdcDelimiter(const DT& delimiter = ",") : _delimiter(delimiter.begin(), delimiter.end())
|
|
{
|
|
}
|
|
|
|
AdcDelimiter(const char* delimiter = ",") : _delimiter(delimiter) {}
|
|
|
|
virtual ~AdcDelimiter() = default;
|
|
|
|
std::string _delimiter;
|
|
};
|
|
|
|
} // namespace details
|
|
|
|
/*
|
|
*/
|
|
template <traits::adc_output_char_range SerializedT = std::string>
|
|
class AdcDefaultSerializer : public details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>
|
|
{
|
|
std::string _delimiter;
|
|
|
|
using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;
|
|
|
|
public:
|
|
template <typename DT = std::string_view>
|
|
AdcDefaultSerializer(const DT& delimiter = ",") : base_t(delimiter)
|
|
{
|
|
}
|
|
|
|
virtual ~AdcDefaultSerializer() = default;
|
|
|
|
template <typename T>
|
|
SerializedT operator()(const T& value)
|
|
{
|
|
SerializedT res;
|
|
|
|
if constexpr (traits::adc_is_tuple_v<T>) {
|
|
AdcCharRangeFromTuple(res, value, _delimiter);
|
|
} else if constexpr (traits::adc_input_char_range<T>) {
|
|
AdcCharRangeFromValueRange(res, value, _delimiter);
|
|
} else {
|
|
res = AdcTrivialSerializer<SerializedT>(value);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
*/
|
|
template <traits::adc_input_char_range SerializedT = std::string>
|
|
class AdcDefaultDeserializer : public details::AdcDelimiter<AdcDefaultDeserializer<SerializedT>>
|
|
{
|
|
std::string _delimiter;
|
|
|
|
using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;
|
|
|
|
public:
|
|
template <typename DT = std::string_view>
|
|
AdcDefaultDeserializer(const DT& delimiter = ",") : base_t(delimiter)
|
|
{
|
|
}
|
|
|
|
virtual ~AdcDefaultDeserializer() = default;
|
|
|
|
template <typename T>
|
|
T deserialization(const SerializedT& value)
|
|
{
|
|
T res;
|
|
|
|
if constexpr (traits::adc_is_tuple_v<T>) {
|
|
AdcTupleFromCharRange(res, value, _delimiter);
|
|
} else if constexpr (traits::adc_output_char_range<T>) {
|
|
AdcValueRangeFromCharRange(res, value, _delimiter);
|
|
} else {
|
|
res = AdcTrivialDeserializer<T>(value);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
};
|
|
|
|
namespace constants
|
|
{
|
|
|
|
static constexpr char DEFAULT_CONVERTER_DELIMITER[] = " ";
|
|
static constexpr char DEFAULT_CONVERTER_DELIMITER_COMA[] = ", ";
|
|
|
|
} // namespace constants
|
|
|
|
template <const char* DELIMITER = constants::DEFAULT_CONVERTER_DELIMITER>
|
|
class AdcDefaultValueConverter
|
|
{
|
|
public:
|
|
static constexpr std::span compositeValueDelimiter{DELIMITER, AdcCharArrSize(DELIMITER)};
|
|
|
|
template <typename SerializedT, typename ValueT>
|
|
static SerializedT serialize(const ValueT& value)
|
|
{
|
|
SerializedT res;
|
|
|
|
if constexpr (traits::adc_is_tuple_v<ValueT>) {
|
|
AdcCharRangeFromTuple(res, value, compositeValueDelimiter);
|
|
} else if constexpr (std::ranges::range<ValueT> && !traits::adc_input_char_range<ValueT>) {
|
|
AdcCharRangeFromValueRange(res, value, compositeValueDelimiter);
|
|
} else {
|
|
res = AdcTrivialSerializer<SerializedT>(value);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
template <typename ValueT, typename SerializedT>
|
|
static ValueT deserialize(const SerializedT& svalue)
|
|
{
|
|
if constexpr (std::is_void_v<ValueT>) {
|
|
return;
|
|
}
|
|
|
|
ValueT res;
|
|
|
|
if constexpr (traits::adc_is_tuple_v<ValueT>) {
|
|
AdcTupleFromCharRange(res, svalue, compositeValueDelimiter);
|
|
} else if constexpr (std::ranges::range<ValueT> && !traits::adc_output_char_range<ValueT>) {
|
|
AdcValueRangeFromCharRange(res, svalue, compositeValueDelimiter);
|
|
} else {
|
|
res = AdcTrivialDeserializer<ValueT>(svalue);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
};
|
|
|
|
|
|
/* join range elements using delimiter between its elements */
|
|
|
|
// NOTE: C++23 has std::views::join_with adapter but here I use upto C++20!!!
|
|
template <std::ranges::input_range R,
|
|
std::ranges::input_range RD,
|
|
std::ranges::output_range<std::ranges::range_value_t<RD>> RO>
|
|
static size_t AdcJoinRange(const R& r, const RD& delim, RO& ro)
|
|
requires std::ranges::range<std::ranges::range_value_t<R>> && // input R is range of ranges
|
|
std::same_as<std::ranges::range_value_t<std::ranges::range_value_t<R>>, std::ranges::range_value_t<RD>>
|
|
{
|
|
auto N = std::ranges::distance(r.begin(), r.end());
|
|
|
|
if (!N) {
|
|
return 0;
|
|
}
|
|
|
|
size_t i = 0;
|
|
|
|
std::ranges::for_each(r, [&](const auto& el) {
|
|
std::ranges::copy(el, std::back_inserter(ro));
|
|
if (++i < N) {
|
|
std::ranges::copy(delim, std::back_inserter(ro));
|
|
}
|
|
});
|
|
|
|
|
|
return N;
|
|
}
|
|
|
|
|
|
// create a range with views of elements of input range and insert a view of input delimiter between them
|
|
|
|
template <std::ranges::input_range R, std::ranges::input_range RD, std::ranges::range RO>
|
|
static size_t AdcReturnRangeElementsView(const R& r, const RD& delim, RO& ro)
|
|
requires std::ranges::range<std::ranges::range_value_t<R>> && // input R is range of ranges
|
|
std::same_as<std::ranges::range_value_t<std::ranges::range_value_t<R>>, std::ranges::range_value_t<RD>> &&
|
|
std::ranges::view<std::ranges::range_value_t<RO>> && // output RO is range of views
|
|
std::same_as<std::ranges::range_value_t<std::ranges::range_value_t<RO>>, std::ranges::range_value_t<RD>>
|
|
{
|
|
auto N = std::ranges::distance(r.begin(), r.end());
|
|
|
|
if (!N) {
|
|
return 0;
|
|
}
|
|
|
|
size_t i = 0;
|
|
|
|
std::ranges::for_each(r, [&](const auto& el) {
|
|
std::back_inserter(ro) = {el.begin(), el.end()};
|
|
if (++i < N) {
|
|
std::back_inserter(ro) = {delim.begin(), delim.end()};
|
|
}
|
|
});
|
|
|
|
return N;
|
|
}
|
|
|
|
|
|
template <std::ranges::range ResT, traits::adc_char_range R, traits::adc_input_char_range DR>
|
|
requires(std::ranges::contiguous_range<R> && traits::adc_char_view<std::ranges::range_value_t<ResT>>) ||
|
|
traits::adc_output_char_range<std::ranges::range_value_t<ResT>>
|
|
static auto AdcSplitCharRange(R&& r, DR&& delim, size_t start = 0, size_t num = std::numeric_limits<size_t>::max())
|
|
{
|
|
ResT res;
|
|
using el_t = std::ranges::range_value_t<ResT>;
|
|
|
|
if (num == 0) {
|
|
return res;
|
|
}
|
|
|
|
|
|
size_t last_el = num;
|
|
if (start) { // to prevent overflowing
|
|
if (num < (std::numeric_limits<size_t>::max() - start + 1)) {
|
|
last_el = start + num - 1;
|
|
}
|
|
} else {
|
|
if (num < (std::numeric_limits<size_t>::max())) {
|
|
last_el = num - 1;
|
|
}
|
|
}
|
|
|
|
auto begin = std::forward<R>(r).begin();
|
|
auto end = std::forward<R>(r).end();
|
|
|
|
auto it_el = begin;
|
|
auto it_next = begin;
|
|
|
|
size_t i_el = 0;
|
|
|
|
auto prev = std::ranges::search(std::forward<R>(r), std::forward<DR>(delim));
|
|
|
|
do {
|
|
if (prev.begin() != begin) {
|
|
if (i_el >= start) {
|
|
std::back_inserter(res) = el_t(it_el, prev.begin());
|
|
}
|
|
|
|
++i_el;
|
|
if (i_el > last_el) {
|
|
break;
|
|
}
|
|
|
|
it_el = prev.end();
|
|
}
|
|
|
|
if (prev.end() == end) {
|
|
break;
|
|
}
|
|
|
|
it_next = prev.end();
|
|
|
|
auto next = std::ranges::search(it_next, end, std::forward<DR>(delim).begin(), std::forward<DR>(delim).end());
|
|
|
|
while (it_next == next.begin()) {
|
|
it_next = next.end();
|
|
|
|
next = std::ranges::search(it_next, end, std::forward<DR>(delim).begin(), std::forward<DR>(delim).end());
|
|
|
|
if (next.empty()) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
prev = next;
|
|
|
|
} while (true);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static constexpr bool AdcCharRangeCompare(const traits::adc_char_view auto& what,
|
|
const traits::adc_char_view auto& where,
|
|
bool case_insensitive = false)
|
|
{
|
|
if (std::ranges::size(what) == std::ranges::size(where)) {
|
|
if (case_insensitive) {
|
|
auto f = std::ranges::search(where,
|
|
std::views::transform(what, [](const char& ch) { return std::tolower(ch); }));
|
|
return !f.empty();
|
|
} else {
|
|
auto f = std::ranges::search(where, what);
|
|
return !f.empty();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// FVN-1a hash function
|
|
template <traits::adc_input_char_range R>
|
|
static constexpr size_t AdcFNV1aHash(const R& r)
|
|
{
|
|
static_assert(sizeof(size_t) == 8 || sizeof(size_t) == 4, "ONLY FOR 32 or 64-bit size_t!!!");
|
|
|
|
size_t hash = 0, prime = 0;
|
|
if constexpr (sizeof(size_t) == 8) { // 64-bit
|
|
prime = 1099511628211UL;
|
|
hash = 14695981039346656037UL;
|
|
} else if constexpr (sizeof(size_t) == 4) { // 32-bit
|
|
prime = 16777619;
|
|
hash = 2166136261;
|
|
}
|
|
|
|
std::ranges::for_each(r, [&hash, &prime](const char& ch) {
|
|
hash ^= ch;
|
|
hash *= prime;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
/* current thread ID std::string representation */
|
|
|
|
static std::string AdcThisThreadId()
|
|
{
|
|
std::stringstream st;
|
|
st << std::this_thread::get_id();
|
|
|
|
return st.str();
|
|
}
|
|
|
|
/* std::basic_ostream based multithread-safe simple logger */
|
|
|
|
template <typename CharT = char, typename CharTraitsT = std::char_traits<CharT>>
|
|
class AdcOstreamLogger
|
|
{
|
|
public:
|
|
typedef CharT char_t;
|
|
typedef CharTraitsT char_traits_t;
|
|
|
|
enum loglevel_t { NULL_LEVEL, ERROR_LEVEL, INFO_LEVEL, DEBUG_LEVEL };
|
|
static constexpr std::array LOGLEVEL_MARK{"null", "error", "info", "debug"};
|
|
|
|
AdcOstreamLogger(std::basic_ostream<CharT, CharTraitsT>& stream = std::cout, loglevel_t log_level = INFO_LEVEL)
|
|
: _logStream(stream), _currentLogLevel(log_level)
|
|
{
|
|
}
|
|
|
|
AdcOstreamLogger(loglevel_t log_level) : _logStream(std::cout), _currentLogLevel(log_level) {}
|
|
|
|
virtual ~AdcOstreamLogger() = default;
|
|
|
|
void setLogLevel(loglevel_t log_level)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_logMutex);
|
|
|
|
_currentLogLevel = log_level;
|
|
}
|
|
|
|
loglevel_t getLogLevel() const
|
|
{
|
|
return _currentLogLevel;
|
|
}
|
|
|
|
void logMessage(loglevel_t level, const std::string& msg)
|
|
{
|
|
std::lock_guard<std::mutex> lock(_logMutex);
|
|
|
|
if (_currentLogLevel < level)
|
|
return;
|
|
|
|
const std::time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
|
|
|
|
// format log-message in form:
|
|
// [YYYY-MM-DD HH:MM:SS][level] log-message
|
|
//
|
|
_logStream << std::put_time(std::localtime(&now), "[%F %T]") << "[" << LOGLEVEL_MARK[level] << "] " << msg
|
|
<< "\n"
|
|
<< std::flush;
|
|
}
|
|
|
|
|
|
void logError(const std::string& msg)
|
|
{
|
|
logMessage(ERROR_LEVEL, msg);
|
|
}
|
|
|
|
void logInfo(const std::string& msg)
|
|
{
|
|
logMessage(INFO_LEVEL, msg);
|
|
}
|
|
|
|
void logDebug(const std::string& msg)
|
|
{
|
|
logMessage(DEBUG_LEVEL, msg);
|
|
}
|
|
|
|
|
|
protected:
|
|
std::basic_ostream<CharT, CharTraitsT>& _logStream;
|
|
loglevel_t _currentLogLevel;
|
|
|
|
std::mutex _logMutex;
|
|
};
|
|
|
|
|
|
} // namespace adc::utils
|