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

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2024-10-08 17:49:48 +03:00
parent 6bd447c458
commit 76d8fb6916
3 changed files with 114 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
net/adc_device_netmsg.h
View File

@@ -13,10 +13,7 @@ namespace constants
{
static constexpr char ADC_DEFAULT_KEY_VALUE_DELIMITER1[] = " ";
static constexpr char ADC_DEFAULT_KEY_PARAM_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_PARAM_PARAM_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_VALUE_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_COMPOSITE_PARAM_DELIMITER[] = ",";
static constexpr char ADC_DEFAULT_COMPOSITE_VALUE_DELIMITER[] = ",";
} // namespace constants
@@ -177,39 +174,6 @@ public:
}
}
// template <typename KeyT, typename ValueT>
// requires traits::adc_output_char_range<ByteSeqT>
// AdcKeyValueMessage& setKeyValue(KeyT&& key, ValueT&& value)
// {
// if (std::ranges::size(_byteSequence)) {
// _byteSequence = ByteSeqT();
// }
// std::ranges::copy(
// utils::AdcDefaultValueConverter<VALUE_DELIM>::template serialize<ByteSeqT>(std::forward<KeyT>(key)),
// std::back_inserter(_byteSequence));
// std::ranges::copy(keyValueDelimiter, std::back_inserter(_byteSequence));
// std::ranges::copy(
// utils::AdcDefaultValueConverter<VALUE_DELIM>::template serialize<ByteSeqT>(std::forward<ValueT>(value)),
// std::back_inserter(_byteSequence));
// return *this;
// }
// template <typename ValueT>
// AdcKeyValueMessage& setValue(ValueT&& value)
// requires traits::adc_output_char_range<ByteSeqT>
// {
// std::vector<char> kw;
// std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));
// return setKeyValue(kw, std::forward<ValueT>(value));
// }
template <typename KeyT, typename... ValuePartTs>
requires traits::adc_output_char_range<ByteSeqT>
AdcKeyValueMessage& setKeyValue(KeyT&& key, ValuePartTs&&... values)
@@ -258,104 +222,6 @@ protected:
};
template <traits::adc_char_range ByteSeqT,
const char* KEY_PARAM_DELIM = constants::ADC_DEFAULT_KEY_PARAM_DELIMITER,
const char* PARAM_PARAM_DELIM = constants::ADC_DEFAULT_PARAM_PARAM_DELIMITER,
const char* COMPOSITE_PARAM_DELIM = constants::ADC_DEFAULT_COMPOSITE_PARAM_DELIMITER>
class AdcDeviceNetMessage : public AdcKeyValueMessage<ByteSeqT, KEY_PARAM_DELIM, COMPOSITE_PARAM_DELIM>
{
using base_t = AdcKeyValueMessage<ByteSeqT, KEY_PARAM_DELIM, COMPOSITE_PARAM_DELIM>;
public:
static constexpr std::span keyParamDelimiter{KEY_PARAM_DELIM, utils::AdcCharArrSize(KEY_PARAM_DELIM)};
static constexpr std::span paramParamDelimiter{PARAM_PARAM_DELIM, utils::AdcCharArrSize(PARAM_PARAM_DELIM)};
static constexpr std::span compParamDelimiter{COMPOSITE_PARAM_DELIM, utils::AdcCharArrSize(COMPOSITE_PARAM_DELIM)};
AdcDeviceNetMessage(ByteSeqT& byte_seq) : base_t(byte_seq) {}
virtual ~AdcDeviceNetMessage() = default;
template <typename T>
requires(std::ranges::contiguous_range<ByteSeqT> && traits::adc_char_view<std::ranges::range_value_t<T>>) ||
traits::adc_range_of_output_char_range<T>
auto params(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
auto val = base_t::template value<std::ranges::range_value_t<T>>();
return utils::AdcSplitCharRange<T>(val, paramParamDelimiter, start, N);
}
auto params(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
return params<std::vector<std::string_view>>(start, N);
} else {
return params<std::vector<std::string>>(start, N);
}
}
template <typename T>
requires traits::adc_output_char_range<T> || traits::adc_char_view<T>
auto joinParams(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
T res;
if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
auto pp = params<std::vector<std::span<const char>>>(start, N);
if (pp.size()) {
res = T{pp.front().begin(), pp.back().end()};
}
} else {
utils::AdcJoinRange(params<std::vector<std::vector<const char>>>(start, N), paramParamDelimiter, res);
}
return res;
}
auto joinParams(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
return joinParams<std::string_view>(start, N);
} else {
return joinParams<std::string>(start, N);
}
}
template <traits::adc_input_char_range KeyT, typename... ParamTs>
requires traits::adc_output_char_range<ByteSeqT>
AdcDeviceNetMessage& setKeyParams(KeyT&& key, ParamTs&&... params)
{
this->setKeyValue(std::forward<KeyT>(key), std::string_view());
if constexpr (sizeof...(ParamTs)) {
setParamsHelper(std::forward<ParamTs>(params)...);
}
return *this;
}
protected:
template <typename ParamT, typename... ParamTs>
void setParamsHelper(ParamT&& param, ParamTs&&... params)
{
std::ranges::copy(utils::AdcDefaultValueConverter<COMPOSITE_PARAM_DELIM>::template serialize<ByteSeqT>(
std::forward<ParamT>(param)),
std::back_inserter(this->_byteSequence));
if constexpr (sizeof...(ParamTs)) {
std::ranges::copy(paramParamDelimiter, std::back_inserter(this->_byteSequence));
setParamsHelper(std::forward<ParamTs>(params)...);
}
}
};
template <traits::adc_char_range ByteSeqT,
const char KEY_VALUE_DELIM[] = constants::ADC_DEFAULT_KEY_VALUE_DELIMITER1,
const char VALUE_DELIM[] = constants::ADC_DEFAULT_VALUE_DELIMITER,
@@ -470,21 +336,41 @@ public:
}
template <typename T>
requires(traits::adc_char_view<T> && std::ranges::contiguous_range<ByteSeqT>) ||
traits::adc_output_char_range<T>
auto key() const
{
return base_t::template key<T>();
}
auto key() const
{
return base_t::key();
}
template <typename T>
auto attrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
return base_t::template valueParts<T>(start, N);
}
auto attrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
return base_t::valueParts(start, N);
}
template <typename T>
auto joinAttrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
return base_t::template joinValueParts<T>(start, N);
}
auto joinAttrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
{
return base_t::joinValueParts(start, N);
}
void ack()
{
@@ -548,4 +434,7 @@ public:
keyHash();
}
};
} // namespace adc