eddy/mountcontrol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2025-10-08 18:13:46 +03:00
parent 27dccfe7c0
commit e0e10395fb
5 changed files with 384 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

356
mcc/mcc_netserver_proto.h
View File

@@ -471,124 +471,392 @@ struct MccNetMessageValidKeywords {
return std::array{mcc::utils::FNV1aHash(NETMSG_VALID_KEYWORDS[Is])...};
}(std::make_index_sequence<NETMSG_VALID_KEYWORDS.size()>());
static std::expected<size_t, std::error_code> isKeywordValid(std::string_view key)
constexpr static const size_t* isKeywordValid(std::string_view key)
{
const auto hash = utils::FNV1aHash(key);
for (auto const& h : NETMSG_VALID_KEYWORD_HASHES) {
if (h == hash) {
return h;
return &h;
}
}
return std::unexpected(std::make_error_code(std::errc::invalid_argument));
return nullptr;
}
};
static_assert(mcc_netmsg_valid_keys_c<MccNetMessageValidKeywords>, "");
template <mcc_netmsg_valid_keys_c BASE_T, traits::mcc_output_char_range BYTEREPR_T>
template <mcc_netmsg_valid_keys_c BASE_T, traits::mcc_char_range BYTEREPR_T>
class MccNetMessage
{
static inline utils::MccSimpleDeserializer defaultDeserilizer{MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ};
public:
typedef BASE_T valid_keys_t;
typedef BYTEREPR_T byte_repr_t;
enum MccNetMessageError { ERROR_OK, ERROR_EMPTY_MESSAGE, ERROR_INVALID_KEYWORD, ERROR_EMPTY_KEYWORD };
MccNetMessage() = default;
template <traits::mcc_input_char_range KT, typename... PTs>
MccNetMessage(KT&& key, PTs&&... params)
requires traits::mcc_output_char_range<BYTEREPR_T>
{
construct(std::forward<KT>(key), std::forward<PTs>(params)...);
}
template <traits::mcc_input_char_range KT>
bool withKey(const KT& key)
template <traits::mcc_input_char_range R>
constexpr MccNetMessage(const R& msg)
requires traits::mcc_input_char_range<BYTEREPR_T>
{
fromCharRange(msg);
}
template <traits::mcc_input_char_range KT>
constexpr bool withKey(const KT& key)
{
if constexpr (std::is_pointer_v<std::decay_t<KT>>) {
return withKey(std::string_view{key});
}
return utils::FNV1aHash(key) == _keywordHash;
}
template <typename T, typename DeserFuncT>
std::expected<T, std::error_code> params(DeserFuncT&& deser_func)
template <traits::mcc_view_or_output_char_range R>
R keyword() const
{
if constexpr (traits::mcc_char_view<R>) {
return R{_keyword.begin(), _keyword.end()};
} else {
R r;
std::ranges::copy(_keyword, std::back_inserter(r));
return r;
}
}
std::string_view keyword() const
{
return _keyword;
}
// template <traits::mcc_view_or_output_char_range R>
// R params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
// {
// if (start_idx >= _params.size()) {
// return R{};
// }
// auto stop_idx = start_idx + Nelemes - 1;
// if (stop_idx >= _params.size()) {
// stop_idx = _params.size() - 1;
// }
// if constexpr (traits::mcc_char_view<R>) {
// return R{_params[start_idx].begin(), _params[stop_idx].end()};
// } else {
// R r;
// std::ranges::copy(std::string_view{_params[start_idx].begin(), _params[stop_idx].end()},
// std::back_inserter(r));
// return r;
// }
// }
template <std::ranges::range R>
R params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
requires(traits::mcc_view_or_output_char_range<R> || traits::mcc_range_of_char_range<R>)
{
if (start_idx >= _params.size()) {
return R{};
}
auto stop_idx = start_idx + Nelemes - 1;
if (stop_idx >= _params.size()) {
stop_idx = _params.size() - 1;
}
if constexpr (traits::mcc_range_of_char_range<R>) { // returm parameters as array
using el_t = std::ranges::range_value_t<R>;
R r;
if constexpr (traits::mcc_char_view<el_t> || traits::mcc_output_char_range<el_t>) {
for (size_t i = start_idx; i <= stop_idx; ++i) {
auto& el = _params[i];
std::back_inserter(r) = el_t{el.begin(), el.end()};
}
} else {
static_assert(false, "UNSUPPORTED RANGE ELEMENT TYPE!!!");
}
return r;
} else {
if constexpr (traits::mcc_char_view<R>) { // return joined parameters as a single char-range
return R{_params[start_idx].begin(), _params[stop_idx].end()};
} else {
R r;
std::ranges::copy(std::string_view{_params[start_idx].begin(), _params[stop_idx].end()},
std::back_inserter(r));
return r;
}
}
}
std::string_view params(size_t start_idx, size_t Nelemes = std::numeric_limits<size_t>::max())
{
return params<std::string_view>(start_idx, Nelemes);
}
template <traits::mcc_view_or_output_char_range R>
R param(size_t idx)
{
if (idx >= _params.size()) {
return {};
}
if constexpr (traits::mcc_char_view<R>) {
return R{_params[idx].begin(), _params[idx].end()};
} else {
R r;
std::ranges::copy(_params[idx], std::back_inserter(r));
return r;
}
}
std::string_view param(size_t idx)
{
if (idx >= _params.size()) {
return {};
}
return _params[idx];
}
template <typename T, typename DeserFuncT>
std::expected<T, std::error_code> paramValue(size_t idx, DeserFuncT&& deser_func)
{
if (idx >= _params.size()) {
return std::unexpected{std::make_error_code(std::errc::argument_out_of_domain)};
}
T val;
auto ec = deser_func(_params, val);
auto ec = std::forward<DeserFuncT>(deser_func)(_params[idx], val);
if (ec) {
return std::unexpect(ec);
return std::unexpected(ec);
} else {
return val;
}
}
template <typename T>
std::expected<T, std::error_code> params()
std::expected<T, std::error_code> paramValue(size_t idx)
{
return params<T>(utils::MccSimpleDeserializer{}.setRangeDelim(MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ));
return paramValue<T>(idx, defaultDeserilizer);
}
template <traits::mcc_view_or_output_char_range R>
R byteRepr() const
{
if constexpr (traits::mcc_char_view<R>) {
return R{_msgBuffer.begin(), _msgBuffer.end()};
} else {
R r;
std::ranges::copy(_msgBuffer, std::back_inserter(r));
return r;
}
}
std::string_view byteRepr() const
{
return byteRepr<std::string_view>();
}
template <traits::mcc_input_char_range KT, typename... PTs>
std::error_code construct(KT&& key, PTs&&... params)
requires traits::mcc_output_char_range<BYTEREPR_T>
{
if constexpr (std::is_pointer_v<std::decay_t<KT>>) {
return construct(std::string_view(key), std::forward<PTs>(params)...);
}
if (!std::ranges::size(key)) {
return std::make_error_code(std::errc::invalid_argument);
}
auto r = valid_keys_t::isKeywordValid(key);
if (!r) {
return r.error();
return std::make_error_code(std::errc::argument_out_of_domain);
}
_keywordHash = r.value();
_keywordHash = *r;
_msgBuffer = BYTEREPR_T{};
std::ranges::copy(key, std::back_inserter(_msgBuffer));
_keyword = {_msgBuffer.begin(), _msgBuffer.end()};
std::ranges::copy(std::forward<KT>(key), std::back_inserter(_msgBuffer));
// _keyword = {_msgBuffer.begin(), _msgBuffer.end()};
size_t key_idx = std::distance(_msgBuffer.begin(), _msgBuffer.end());
std::vector<size_t> par_idx;
_params = std::string_view{};
_params.clear();
if constexpr (sizeof...(PTs)) {
std::ranges::copy(MCC_COMMPROTO_KEYPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
[this]<typename T, typename... Ts>(this auto&& self, const T& par, const Ts&... pars) {
if constexpr (std::is_arithmetic_v<T>) {
std::ranges::copy(std::to_string(par), std::back_inserter(_msgBuffer));
} else if constexpr (std::convertible_to<T, std::string>) {
std::ranges::copy(static_cast<std::string>(par), std::back_inserter(_msgBuffer));
} else if constexpr (std::constructible_from<std::string, T>) {
std::ranges::copy(std::string(par), std::back_inserter(_msgBuffer));
} else if constexpr (traits::mcc_char_range<T>) {
std::ranges::copy(std::string(par.begin(), par.end()), std::back_inserter(_msgBuffer));
} else if constexpr (std::same_as<T, MccCoordPairKind>) {
std::ranges::copy(mcc_pairkind2str(par), std::back_inserter(_msgBuffer));
} else if constexpr (traits::mcc_time_duration_c<T>) {
std::forward<decltype(self)>(self)(par.count());
} else {
static_assert(false, "UNSUPPORTED TYPE!!!");
}
convertFunc(par_idx, std::forward<PTs>(params)...);
if constexpr (sizeof...(Ts)) {
std::ranges::copy(MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
std::forward<decltype(self)>(self)(pars...);
}
}(std::forward<PTs>(params)...);
_params = {_msgBuffer.begin() + _keyword.size() + MCC_COMMPROTO_KEYPARAM_DELIM_SEQ.size(),
_msgBuffer.end()};
for (size_t i = 0; i < par_idx.size(); i += 2) {
_params.emplace_back(_msgBuffer.begin() + par_idx[i], _msgBuffer.begin() + par_idx[i + 1]);
}
}
_keyword = std::string_view{_msgBuffer.begin(), _msgBuffer.begin() + key_idx};
return {};
}
template <traits::mcc_input_char_range R>
constexpr MccNetMessageError fromCharRange(const R& r)
{
if constexpr (std::is_pointer_v<std::decay_t<R>>) {
return fromCharRange(std::string_view(r));
}
if (std::ranges::size(r) == 0) {
return ERROR_EMPTY_MESSAGE;
}
std::string_view key, val;
auto prev_msg_buff = _msgBuffer;
if constexpr (traits::mcc_output_char_range<BYTEREPR_T>) {
_msgBuffer = BYTEREPR_T{};
std::ranges::copy(r, std::back_inserter(_msgBuffer));
} else {
_msgBuffer = {std::begin(r), std::end(r)};
}
auto found = std::ranges::search(_msgBuffer, MCC_COMMPROTO_KEYPARAM_DELIM_SEQ);
if (found.empty()) { // only keyword
key = utils::trimSpaces(std::string_view{_msgBuffer.begin(), _msgBuffer.end()});
} else {
key = utils::trimSpaces(std::string_view{_msgBuffer.begin(), found.begin()});
}
auto kv = valid_keys_t::isKeywordValid(key);
if (!kv) {
// _msgBuffer = prev_msg_buff; // restore previous netmessage state
return ERROR_INVALID_KEYWORD;
}
_keywordHash = *kv;
_keyword = key;
if (!found.empty()) { // params ...
_params.clear();
auto pr =
std::views::split(std::string_view{found.end(), _msgBuffer.end()}, MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ);
for (auto const& p : pr) {
_params.emplace_back(p.begin(), p.end());
}
}
return ERROR_OK;
}
protected:
size_t _keywordHash{};
std::string_view _keyword{};
std::string_view _params{};
std::vector<std::string_view> _params{};
BYTEREPR_T _msgBuffer{};
template <typename T, typename... Ts>
void convertFunc(std::vector<size_t>& idx, const T& par, const Ts&... pars)
{
idx.emplace_back(std::distance(_msgBuffer.begin(), _msgBuffer.end()));
// if constexpr (std::is_arithmetic_v<T>) {
// std::format_to(std::back_inserter(_msgBuffer), "{}", par);
// } else if constexpr (std::convertible_to<T, std::string>) {
// std::ranges::copy(static_cast<std::string>(par), std::back_inserter(_msgBuffer));
// } else if constexpr (std::constructible_from<std::string, T>) {
// std::ranges::copy(std::string(par), std::back_inserter(_msgBuffer));
// } else if constexpr (traits::mcc_char_range<T>) {
// std::ranges::copy(std::string(par.begin(), par.end()), std::back_inserter(_msgBuffer));
// } else if constexpr (std::same_as<T, MccCoordPairKind>) {
// std::ranges::copy(mcc_pairkind2str(par), std::back_inserter(_msgBuffer));
// } else if constexpr (traits::mcc_time_duration_c<T>) {
// idx.resize(idx.size() - 1);
// convertFunc(idx, par.count());
// idx.resize(idx.size() - 1);
// } else if constexpr (std::formattable<T, char>) {
// std::format_to(std::back_inserter(_msgBuffer), "{}", par);
// } else {
// static_assert(false, "UNSUPPORTED TYPE!!!");
// }
// use the lambda here to enable recursive calling with no special handling of 'idx'
[](this auto const& self, auto& buff, auto const& p) {
using p_t = std::decay_t<decltype(p)>;
if constexpr (std::is_arithmetic_v<p_t>) {
std::format_to(std::back_inserter(buff), "{}", p);
} else if constexpr (std::convertible_to<p_t, std::string>) {
std::ranges::copy(static_cast<std::string>(p), std::back_inserter(buff));
} else if constexpr (std::constructible_from<std::string, p_t>) {
std::ranges::copy(std::string(p), std::back_inserter(buff));
} else if constexpr (traits::mcc_char_range<p_t>) {
std::ranges::copy(std::string(p.begin(), p.end()), std::back_inserter(buff));
} else if constexpr (std::same_as<p_t, MccCoordPairKind>) {
std::ranges::copy(mcc_pairkind2str(p), std::back_inserter(buff));
} else if constexpr (traits::mcc_time_duration_c<p_t>) {
self(buff, p.count());
} else if constexpr (std::ranges::range<p_t>) {
auto sz = std::ranges::size(p);
if (sz == 0) {
return;
}
self(buff, *p.begin()); // the first element
if (sz > 1) {
for (auto const& el : p | std::views::drop(1)) {
std::ranges::copy(MCC_COMMPROTO_RANGEPARAM_DELIM_SEQ, std::back_inserter(buff));
self(buff, el);
}
}
} else if constexpr (std::formattable<p_t, char>) {
std::format_to(std::back_inserter(buff), "{}", p);
} else {
static_assert(false, "UNSUPPORTED TYPE!!!");
}
}(_msgBuffer, par);
idx.emplace_back(std::distance(_msgBuffer.begin(), _msgBuffer.end()));
if constexpr (sizeof...(Ts)) {
std::ranges::copy(MCC_COMMPROTO_PARAMPARAM_DELIM_SEQ, std::back_inserter(_msgBuffer));
convertFunc(idx, pars...);
}
};
};
static_assert(MccNetMessage<MccNetMessageValidKeywords, std::string_view>{"ACK"}.withKey("ACK"));
} // namespace mcc::network