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

mcc_keyvalue.h: worked

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2026-05-19 12:16:22 +03:00
parent d40ecb5df7
commit 8d36444c51
2 changed files with 90 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
include/mcc/mcc_keyvalue.h
View File

@@ -97,7 +97,7 @@ template <typename T>
concept mcc_keyvalue_record_c = requires(T t) { concept mcc_keyvalue_record_c = requires(T t) {
requires std::same_as<decltype(t.key), const std::string_view>; // key name is immutable!!! requires std::same_as<decltype(t.key), const std::string_view>; // key name is immutable!!!
requires mcc_variant_valid_type_c<decltype(t.value)>; // value is mutable requires mcc_variant_valid_type_c<decltype(t.value)>; // value is mutable
requires mcc_variant_valid_type_c<decltype(t.default_value)>; // value is mutable requires mcc_variant_valid_type_c<decltype(t.default_value)>; // default value is mutable
requires mcc_serialization_params_c<decltype(t.serial_pars)>; // serialization parameters requires mcc_serialization_params_c<decltype(t.serial_pars)>; // serialization parameters
}; };
@@ -112,15 +112,15 @@ namespace constants
static constexpr char MCC_KV_COMMENT_SEQ_ARR[] = "#"; static constexpr char MCC_KV_COMMENT_SEQ_ARR[] = "#";
static constexpr char MCC_KV_KEY_VALUE_DELIM_SEQ_ARR[] = "="; static constexpr char MCC_KV_KEY_VALUE_DELIM_SEQ_ARR[] = "=";
static constexpr char MCC_KV_VALUE_ARRAY_DELIM_SEQ_ARR[] = ","; static constexpr char MCC_KV_COMPOSITE_VALUE_DELIM_SEQ_ARR[] = ",";
} // namespace constants } // namespace constants
template <mcc_keyvalue_desc_c DESCR_T, template <mcc_keyvalue_desc_c DESCR_T,
const char* COMM_SEQ = constants::MCC_KV_COMMENT_SEQ_ARR, const char* COMM_SEQ = constants::MCC_KV_COMMENT_SEQ_ARR, // comment char sequence
const char* KV_DELIM = constants::MCC_KV_KEY_VALUE_DELIM_SEQ_ARR, const char* KV_DELIM = constants::MCC_KV_KEY_VALUE_DELIM_SEQ_ARR // key-value delimiter
const char* ARR_DELIM = constants::MCC_KV_VALUE_ARRAY_DELIM_SEQ_ARR> >
class MccKeyValueHolder class MccKeyValueHolder
{ {
public: public:
@@ -138,11 +138,6 @@ public:
: KV_DELIM[0] == '\0' ? constants::MCC_KV_KEY_VALUE_DELIM_SEQ_ARR : KV_DELIM[0] == '\0' ? constants::MCC_KV_KEY_VALUE_DELIM_SEQ_ARR
: KV_DELIM}; : KV_DELIM};
static constexpr std::string_view VALUE_ARRAY_DELIM{
ARR_DELIM == nullptr ? constants::MCC_KV_VALUE_ARRAY_DELIM_SEQ_ARR
: ARR_DELIM[0] == '\0' ? constants::MCC_KV_VALUE_ARRAY_DELIM_SEQ_ARR
: ARR_DELIM};
static constexpr size_t NUMBER_OF_RECORDS = std::tuple_size_v<DESCR_T>; static constexpr size_t NUMBER_OF_RECORDS = std::tuple_size_v<DESCR_T>;
MccKeyValueHolder(DESCR_T desc) : _keyValue(desc) MccKeyValueHolder(DESCR_T desc) : _keyValue(desc)
@@ -155,7 +150,7 @@ public:
} }
constexpr std::array<std::string_view, NUMBER_OF_RECORDS> keys() const std::array<std::string_view, NUMBER_OF_RECORDS> keys() const
{ {
return [this]<size_t... Is>(std::index_sequence<Is...>) { return [this]<size_t... Is>(std::index_sequence<Is...>) {
return std::array<std::string_view, NUMBER_OF_RECORDS>{std::get<Is>(_keyValue).key...}; return std::array<std::string_view, NUMBER_OF_RECORDS>{std::get<Is>(_keyValue).key...};
@@ -322,61 +317,63 @@ public:
template <OutputPolicy OPOLICY = MccKeyValueHolder::OPOLICY_CHANGED_ONLY, template <OutputPolicy OPOLICY = MccKeyValueHolder::OPOLICY_CHANGED_ONLY,
traits::mcc_output_char_range R, traits::mcc_output_char_range R,
traits::mcc_input_char_range RecDelimT = std::string_view, traits::mcc_input_char_range RecDelimT = std::string_view>
mcc_serialization_params_c SerParamsT = mcc_serialization_params_t>
std::error_code toCharRange(R& output_buffer, RecDelimT rec_delim = std::string_view{"\n"}) std::error_code toCharRange(R& output_buffer, RecDelimT rec_delim = std::string_view{"\n"})
{ {
if (std::is_pointer_v<std::decay_t<RecDelimT>>) { // char*, const char*, char[], conat char[]
return toCharRange(output_buffer, std::string_view{rec_delim});
}
std::error_code ec{}; std::error_code ec{};
auto write_rec = [&output_buffer, &rec_delim, &ec, this]<size_t I = 0>(this auto& self) { auto write_rec = [&output_buffer, &rec_delim, &ec, this]<size_t I = 0>(this auto& self) {
if constexpr (I < NUMBER_OF_RECORDS) { if constexpr (I < NUMBER_OF_RECORDS) {
using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
const val_t* value_cptr = &std::get<I>(_keyValue).value;
if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_CHANGED_ONLY) { if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_CHANGED_ONLY) {
if (_changedKey.count(_hashes[I]) == 0) { if (_changedKey.count(_hashes[I]) == 0) {
self.template operator()<I + 1>(); self.template operator()<I + 1>();
return; return;
} }
} else if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_FULL) {
if (_changedKey.count(_hashes[I]) == 0) {
value_cptr = &std::get<I>(_keyValue).default_value;
}
} else {
static_assert(false, "UNKNOWN OUTPUT POLICY VALUE!");
} }
auto key = std::get<I>(_keyValue).key; ec = formatRecord<I>(output_buffer, rec_delim);
if (ec) {
std::string buff;
auto err =
MccSerializer<val_t>{}(buff, std::get<I>(_keyValue).value, std::get<I>(_keyValue).serial_pars);
if (err) {
ec = MccKeyValueHolderErrorCode::ERROR_SERIAL;
return; return;
} else {
size_t hash = _hashes[I];
// write head comment
if (_headComment[hash].size()) {
for (auto const& comm : _headComment[hash]) {
if (comm.has_value()) {
std::format_to(std::back_inserter(output_buffer), "{}{}", COMM_SEQ, comm.value());
}
std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
}
} }
// key and value // using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
std::format_to(std::back_inserter(output_buffer), "{}{}{}", key, KEY_VALUE_DELIM, buff);
// inline comment // auto key = std::get<I>(_keyValue).key;
if (_inlineComment[hash].size()) {
std::format_to(std::back_inserter(output_buffer), " {}{}", COMMENT_SEQ, _inlineComment[hash]);
}
// record delimiter // std::string buff;
std::ranges::copy(rec_delim, std::back_inserter(output_buffer)); // auto err =
} // MccSerializer<val_t>{}(buff, std::get<I>(_keyValue).value, std::get<I>(_keyValue).serial_pars);
// if (err) {
// ec = MccKeyValueHolderErrorCode::ERROR_SERIAL;
// return;
// } else {
// size_t hash = _hashes[I];
// // write head comment
// if (_headComment[hash].size()) {
// for (auto const& comm : _headComment[hash]) {
// if (comm.has_value()) {
// std::format_to(std::back_inserter(output_buffer), "{}{}", COMM_SEQ, comm.value());
// }
// std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
// }
// }
// // key and value
// std::format_to(std::back_inserter(output_buffer), "{}{}{}", key, KEY_VALUE_DELIM, buff);
// // inline comment
// if (_inlineComment[hash].size()) {
// std::format_to(std::back_inserter(output_buffer), " {}{}", COMMENT_SEQ,
// _inlineComment[hash]);
// }
// // record delimiter
// std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
// }
self.template operator()<I + 1>(); self.template operator()<I + 1>();
} }
@@ -433,47 +430,51 @@ protected:
return MccKeyValueHolderErrorCode::ERROR_INVALID_KEY; return MccKeyValueHolderErrorCode::ERROR_INVALID_KEY;
} }
// template <size_t I = 0, template <size_t I = 0, traits::mcc_output_char_range R, traits::mcc_input_char_range RecDelimT>
// traits::mcc_output_char_range R, std::error_code formatRecord(R& output_buffer, RecDelimT rec_delim, bool is_default = false)
// traits::mcc_input_char_range RecDelimT, {
// mcc_serialization_params_c SerParamsT> if constexpr (I < NUMBER_OF_RECORDS) {
// std::error_code writeRecord(DESCR_T const& holder, R& output_buffer, RecDelimT rec_delim) auto key = std::get<I>(_keyValue).key;
// { using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
// if constexpr (I < NUMBER_OF_RECORDS) {
// auto key = std::get<I>(holder).key;
// using val_t = std::remove_cvref_t<decltype(std::get<I>(holder).value)>;
// std::string buff; val_t& val_ptr = std::get<I>(_keyValue).value;
// auto err = MccSerializer<val_t>{}(buff, std::get<I>(holder).value, std::get<I>(holder).serial_pars); if (is_default) {
// if (err) { val_ptr = std::get<I>(_keyValue).default_value;
// return MccKeyValueHolderErrorCode::ERROR_SERIAL; }
// } else {
// size_t hash = _hashes[I];
// // write head comment
// if (_headComment[hash].size()) {
// for (auto const& comm : _headComment[hash]) {
// if (comm.has_value()) {
// std::format_to(std::back_inserter(output_buffer), "{}{}", COMM_SEQ, comm.value());
// }
// std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
// }
// }
// // key and value std::string buff;
// std::format_to(std::back_inserter(output_buffer), "{}{}{}", key, KEY_VALUE_DELIM, buff); // auto err = MccSerializer<val_t>{}(buff, std::get<I>(_keyValue).value,
// std::get<I>(_keyValue).serial_pars);
auto err = MccSerializer<val_t>{}(buff, val_ptr, std::get<I>(_keyValue).serial_pars);
if (err) {
return MccKeyValueHolderErrorCode::ERROR_SERIAL;
} else {
size_t hash = _hashes[I];
// write head comment
if (_headComment[hash].size()) {
for (auto const& comm : _headComment[hash]) {
if (comm.has_value()) {
std::format_to(std::back_inserter(output_buffer), "{}{}", COMM_SEQ, comm.value());
}
std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
}
}
// // inline comment // key and value
// if (_inlineComment[hash].size()) { std::format_to(std::back_inserter(output_buffer), "{}{}{}", key, KEY_VALUE_DELIM, buff);
// std::format_to(std::back_inserter(output_buffer), " {}{}", COMMENT_SEQ, _inlineComment[hash]);
// }
// // record delimiter // inline comment
// std::ranges::copy(rec_delim, std::back_inserter(output_buffer)); if (_inlineComment[hash].size()) {
// } std::format_to(std::back_inserter(output_buffer), " {}{}", COMMENT_SEQ, _inlineComment[hash]);
// } }
// return MccKeyValueHolderErrorCode::ERROR_OK; // record delimiter
// } std::ranges::copy(rec_delim, std::back_inserter(output_buffer));
}
}
return MccKeyValueHolderErrorCode::ERROR_OK;
}
}; };
template <mcc_variant_valid_type_c T> template <mcc_variant_valid_type_c T>

3
tests/mcc_keyvalue_test.cpp
View File

@@ -11,7 +11,8 @@ static auto kv_desc = std::make_tuple(
mcc_simple_kv_record_t{ mcc_simple_kv_record_t{
"ddd", MccAngle{11.5_degs}, MccAngle{11.5_degs}, "ddd", MccAngle{11.5_degs}, MccAngle{11.5_degs},
mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}}, mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}},
mcc_make_simple_kv_record("eee", 1.5)); mcc_make_simple_kv_record("eee", 1.5),
mcc_make_simple_kv_record("arr", std::vector<int>{1, 2, 3, 4, 5, 6, 7}));