timur/mcc
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-05-18 17:19:40 +03:00
parent d8130cede2
commit d40ecb5df7
2 changed files with 61 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
include/mcc/mcc_keyvalue.h
View File

@@ -97,6 +97,7 @@ template <typename 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 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_serialization_params_c<decltype(t.serial_pars)>; // serialization parameters
};
@@ -162,6 +163,13 @@ public:
}
void setToDefaults()
{
[this]<size_t... Is>(std::index_sequence<Is...>) {
((std::get<Is>(_keyValue).value = std::get<Is>(_keyValue).default_value), ...);
}(std::make_index_sequence<NUMBER_OF_RECORDS>{});
}
template <typename T, std::ranges::contiguous_range R>
std::expected<T, std::error_code> getValue(R const& key) const
{
@@ -248,6 +256,9 @@ public:
_inlineComment.clear();
_changedKey.clear();
// set values to its defaults
setToDefaults();
auto recs = std::views::split(buffer, std::move(rec_delim));
for (auto const& el : recs) {
@@ -319,15 +330,23 @@ public:
auto write_rec = [&output_buffer, &rec_delim, &ec, this]<size_t I = 0>(this auto& self) {
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 (_changedKey.count(_hashes[I]) == 0) {
self.template operator()<I + 1>();
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;
using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
std::string buff;
auto err =
@@ -415,25 +434,17 @@ protected:
}
// template <size_t I = 0,
// OutputPolicy OPOLICY = MccKeyValueHolder::OPOLICY_CHANGED_ONLY,
// traits::mcc_output_char_range R,
// traits::mcc_input_char_range RecDelimT,
// mcc_serialization_params_c SerParamsT>
// std::error_code writeRecord(R& output_buffer, RecDelimT rec_delim, SerParamsT const& ser_params)
// std::error_code writeRecord(DESCR_T const& holder, R& output_buffer, RecDelimT rec_delim)
// {
// if constexpr (I < NUMBER_OF_RECORDS) {
// if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_CHANGED_ONLY) {
// if (_changedKey.count(_hashes[I]) == 0) {
// return MccKeyValueHolderErrorCode::ERROR_OK;
// }
// }
// auto key = std::get<I>(_keyValue).key;
// auto val = std::get<I>(_keyValue).value;
// using val_t = std::remove_cvref_t<decltype(val)>;
// auto key = std::get<I>(holder).key;
// using val_t = std::remove_cvref_t<decltype(std::get<I>(holder).value)>;
// std::string buff;
// auto err = MccSerializer<val_t>{}(buff, val, ser_params);
// auto err = MccSerializer<val_t>{}(buff, std::get<I>(holder).value, std::get<I>(holder).serial_pars);
// if (err) {
// return MccKeyValueHolderErrorCode::ERROR_SERIAL;
// } else {
@@ -468,8 +479,17 @@ protected:
template <mcc_variant_valid_type_c T>
struct mcc_simple_kv_record_t {
const std::string_view key;
T value;
T value, default_value;
mcc_serialization_params_t serial_pars;
};
template <mcc_variant_valid_type_c T>
mcc_simple_kv_record_t<T> mcc_make_simple_kv_record(
std::string_view key,
T const& def_value,
mcc_serialization_params_t const& spars = mcc_serialization_params_t{})
{
return mcc_simple_kv_record_t<T>{key, def_value, def_value, spars};
}
} // namespace mcc::impl

34
tests/mcc_keyvalue_test.cpp
View File

@@ -5,12 +5,13 @@
using namespace mcc::impl;
static auto kv_desc = std::make_tuple(
mcc_simple_kv_record_t{"bb", MccAngle{11.5_degs}, mcc_serialization_params_t{}},
mcc_simple_kv_record_t{"aaa", std::string("AAA"), mcc_serialization_params_t{}},
mcc_simple_kv_record_t{"cc", MccCelestialCoordEpoch{}, mcc_serialization_params_t{}},
mcc_simple_kv_record_t{"bb", MccAngle{11.5_degs}, MccAngle{11.5_degs}, mcc_serialization_params_t{}},
mcc_simple_kv_record_t{"aaa", std::string("AAA"), std::string("AAA"), mcc_serialization_params_t{}},
mcc_simple_kv_record_t{"cc", MccCelestialCoordEpoch{}, MccCelestialCoordEpoch{}, mcc_serialization_params_t{}},
mcc_simple_kv_record_t{
"ddd", MccAngle{11.5_degs},
mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}});
"ddd", MccAngle{11.5_degs}, MccAngle{11.5_degs},
mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}},
mcc_make_simple_kv_record("eee", 1.5));
@@ -37,10 +38,29 @@ ddd = 01:02:33.434 # HA in hours:mins:secs
int main()
{
std::error_code err;
std::string buff;
MccKeyValueHolder kv(kv_desc);
err = kv.toCharRange(buff);
if (err) {
std::println("ERR = {}", err);
return 1;
}
std::println("DEFAULT VALUES:");
std::println("--(\n{})--", buff);
std::println("\n\n");
err = kv.setValue("eee", 15.1515);
if (err) {
std::println("ERR = {}", err);
// return 1;
}
// auto err = kv.fromCharRange(STR);
auto err = kv.fromCharRange(STR1);
err = kv.fromCharRange(STR1);
if (err) {
std::println("ERR = {}", err);
return 1;
@@ -69,8 +89,8 @@ int main()
std::println("------------------------------------");
std::string buff;
buff.clear();
err = kv.toCharRange<decltype(kv)::OPOLICY_FULL>(buff);
// err = kv.toCharRange(buff);
if (err) {