diff --git a/generated/include/mmx/pooling_error_e.hxx b/generated/include/mmx/pooling_error_e.hxx index f15f233a3..02351e45f 100644 --- a/generated/include/mmx/pooling_error_e.hxx +++ b/generated/include/mmx/pooling_error_e.hxx @@ -13,22 +13,22 @@ namespace mmx { struct MMX_EXPORT pooling_error_e { enum enum_t : uint32_t { - CHALLENGE_NOT_FOUND = 3l, - CHALLENGE_REVERTED = 1l, - DUPLICATE_PARTIAL = 17l, - INVALID_ACCOUNT = 13l, - INVALID_AUTH_KEY = 12l, - INVALID_CONTRACT = 9l, - INVALID_DIFFICULTY = 6l, - INVALID_PROOF = 4l, - INVALID_SIGNATURE = 7l, - INVALID_TIMESTAMP = 15l, + CHALLENGE_NOT_FOUND = 471927302l, + CHALLENGE_REVERTED = 1760085717l, + DUPLICATE_PARTIAL = 271202490l, + INVALID_ACCOUNT = 3369359198l, + INVALID_AUTH_KEY = 1953340654l, + INVALID_CONTRACT = 914919857l, + INVALID_DIFFICULTY = 1883406896l, + INVALID_PARTIAL = 405897781l, + INVALID_PROOF = 3117556933l, + INVALID_SIGNATURE = 3529800621l, + INVALID_TIMESTAMP = 2157722321l, NONE = 0l, - PARTIAL_NOT_GOOD_ENOUGH = 5l, - PARTIAL_TOO_LATE = 2l, - POOL_LOST_SYNC = 16l, - SERVER_ERROR = 8l, - UNKNOWN_FARMER = 10l, + PARTIAL_NOT_GOOD_ENOUGH = 1161496011l, + PARTIAL_TOO_LATE = 2832488076l, + POOL_LOST_SYNC = 1324712875l, + SERVER_ERROR = 2095599592l, }; ::mmx::pooling_error_e::enum_t value = ::mmx::pooling_error_e::enum_t(0); diff --git a/generated/include/mmx/pooling_stats_t.hxx b/generated/include/mmx/pooling_stats_t.hxx index 037e62808..2d4d07fce 100644 --- a/generated/include/mmx/pooling_stats_t.hxx +++ b/generated/include/mmx/pooling_stats_t.hxx @@ -18,6 +18,8 @@ struct MMX_EXPORT pooling_stats_t : vnx::struct_t { uint64_t partial_diff = 0; uint64_t valid_points = 0; uint64_t failed_points = 0; + uint32_t total_partials = 0; + int64_t total_response_time = 0; std::map<::mmx::pooling_error_e, uint32_t> error_count; static const vnx::Hash64 VNX_TYPE_HASH; @@ -60,13 +62,15 @@ struct MMX_EXPORT pooling_stats_t : vnx::struct_t { template void pooling_stats_t::accept_generic(T& _visitor) const { - _visitor.template type_begin(5); + _visitor.template type_begin(7); _visitor.type_field("server_url", 0); _visitor.accept(server_url); _visitor.type_field("partial_diff", 1); _visitor.accept(partial_diff); _visitor.type_field("valid_points", 2); _visitor.accept(valid_points); _visitor.type_field("failed_points", 3); _visitor.accept(failed_points); - _visitor.type_field("error_count", 4); _visitor.accept(error_count); - _visitor.template type_end(5); + _visitor.type_field("total_partials", 4); _visitor.accept(total_partials); + _visitor.type_field("total_response_time", 5); _visitor.accept(total_response_time); + _visitor.type_field("error_count", 6); _visitor.accept(error_count); + _visitor.template type_end(7); } diff --git a/generated/src/FarmInfo.cpp b/generated/src/FarmInfo.cpp index d2f1e64c2..6779d8c38 100644 --- a/generated/src/FarmInfo.cpp +++ b/generated/src/FarmInfo.cpp @@ -16,7 +16,7 @@ namespace mmx { const vnx::Hash64 FarmInfo::VNX_TYPE_HASH(0xa2701372b9137f0eull); -const vnx::Hash64 FarmInfo::VNX_CODE_HASH(0x9ed7e0fdc5e5cff5ull); +const vnx::Hash64 FarmInfo::VNX_CODE_HASH(0xc7a28ee2b06133dull); vnx::Hash64 FarmInfo::get_type_hash() const { return VNX_TYPE_HASH; @@ -207,7 +207,7 @@ std::shared_ptr FarmInfo::static_create_type_code() { auto type_code = std::make_shared(); type_code->name = "mmx.FarmInfo"; type_code->type_hash = vnx::Hash64(0xa2701372b9137f0eull); - type_code->code_hash = vnx::Hash64(0x9ed7e0fdc5e5cff5ull); + type_code->code_hash = vnx::Hash64(0xc7a28ee2b06133dull); type_code->is_native = true; type_code->is_class = true; type_code->native_size = sizeof(::mmx::FarmInfo); diff --git a/generated/src/Node_verify_partial_return.cpp b/generated/src/Node_verify_partial_return.cpp index 0a074dcb3..f35bcbc2a 100644 --- a/generated/src/Node_verify_partial_return.cpp +++ b/generated/src/Node_verify_partial_return.cpp @@ -13,7 +13,7 @@ namespace mmx { const vnx::Hash64 Node_verify_partial_return::VNX_TYPE_HASH(0xb64fb769c6ffcf36ull); -const vnx::Hash64 Node_verify_partial_return::VNX_CODE_HASH(0x9400edfc074cc130ull); +const vnx::Hash64 Node_verify_partial_return::VNX_CODE_HASH(0x717d0eb6082d2766ull); vnx::Hash64 Node_verify_partial_return::get_type_hash() const { return VNX_TYPE_HASH; @@ -114,7 +114,7 @@ std::shared_ptr Node_verify_partial_return::static_create_type_co auto type_code = std::make_shared(); type_code->name = "mmx.Node.verify_partial.return"; type_code->type_hash = vnx::Hash64(0xb64fb769c6ffcf36ull); - type_code->code_hash = vnx::Hash64(0x9400edfc074cc130ull); + type_code->code_hash = vnx::Hash64(0x717d0eb6082d2766ull); type_code->is_native = true; type_code->is_class = true; type_code->is_return = true; diff --git a/generated/src/Node_verify_plot_nft_target_return.cpp b/generated/src/Node_verify_plot_nft_target_return.cpp index bc8a2189a..fbe36b9f2 100644 --- a/generated/src/Node_verify_plot_nft_target_return.cpp +++ b/generated/src/Node_verify_plot_nft_target_return.cpp @@ -13,7 +13,7 @@ namespace mmx { const vnx::Hash64 Node_verify_plot_nft_target_return::VNX_TYPE_HASH(0x82f0f6ed43a0c4bull); -const vnx::Hash64 Node_verify_plot_nft_target_return::VNX_CODE_HASH(0xdbc661f33fe94daeull); +const vnx::Hash64 Node_verify_plot_nft_target_return::VNX_CODE_HASH(0x3ebb82b93088abf8ull); vnx::Hash64 Node_verify_plot_nft_target_return::get_type_hash() const { return VNX_TYPE_HASH; @@ -114,7 +114,7 @@ std::shared_ptr Node_verify_plot_nft_target_return::static_create auto type_code = std::make_shared(); type_code->name = "mmx.Node.verify_plot_nft_target.return"; type_code->type_hash = vnx::Hash64(0x82f0f6ed43a0c4bull); - type_code->code_hash = vnx::Hash64(0xdbc661f33fe94daeull); + type_code->code_hash = vnx::Hash64(0x3ebb82b93088abf8ull); type_code->is_native = true; type_code->is_class = true; type_code->is_return = true; diff --git a/generated/src/pooling_error_e.cpp b/generated/src/pooling_error_e.cpp index 36c58ed97..4c6ebc990 100644 --- a/generated/src/pooling_error_e.cpp +++ b/generated/src/pooling_error_e.cpp @@ -11,7 +11,7 @@ namespace mmx { const vnx::Hash64 pooling_error_e::VNX_TYPE_HASH(0xec786b877a93f17ull); -const vnx::Hash64 pooling_error_e::VNX_CODE_HASH(0xbcf2569e7ac5f81eull); +const vnx::Hash64 pooling_error_e::VNX_CODE_HASH(0x67403d1659447023ull); vnx::Hash64 pooling_error_e::get_type_hash() const { return VNX_TYPE_HASH; @@ -50,6 +50,7 @@ vnx::bool_t pooling_error_e::is_valid() const { case INVALID_AUTH_KEY: return true; case INVALID_CONTRACT: return true; case INVALID_DIFFICULTY: return true; + case INVALID_PARTIAL: return true; case INVALID_PROOF: return true; case INVALID_SIGNATURE: return true; case INVALID_TIMESTAMP: return true; @@ -58,7 +59,6 @@ vnx::bool_t pooling_error_e::is_valid() const { case PARTIAL_TOO_LATE: return true; case POOL_LOST_SYNC: return true; case SERVER_ERROR: return true; - case UNKNOWN_FARMER: return true; } return false; } @@ -72,6 +72,7 @@ std::string pooling_error_e::to_string() const { case INVALID_AUTH_KEY: return "\"INVALID_AUTH_KEY\""; case INVALID_CONTRACT: return "\"INVALID_CONTRACT\""; case INVALID_DIFFICULTY: return "\"INVALID_DIFFICULTY\""; + case INVALID_PARTIAL: return "\"INVALID_PARTIAL\""; case INVALID_PROOF: return "\"INVALID_PROOF\""; case INVALID_SIGNATURE: return "\"INVALID_SIGNATURE\""; case INVALID_TIMESTAMP: return "\"INVALID_TIMESTAMP\""; @@ -80,7 +81,6 @@ std::string pooling_error_e::to_string() const { case PARTIAL_TOO_LATE: return "\"PARTIAL_TOO_LATE\""; case POOL_LOST_SYNC: return "\"POOL_LOST_SYNC\""; case SERVER_ERROR: return "\"SERVER_ERROR\""; - case UNKNOWN_FARMER: return "\"UNKNOWN_FARMER\""; } return std::to_string(value); } @@ -94,6 +94,7 @@ std::string pooling_error_e::to_string_value() const { case INVALID_AUTH_KEY: return "INVALID_AUTH_KEY"; case INVALID_CONTRACT: return "INVALID_CONTRACT"; case INVALID_DIFFICULTY: return "INVALID_DIFFICULTY"; + case INVALID_PARTIAL: return "INVALID_PARTIAL"; case INVALID_PROOF: return "INVALID_PROOF"; case INVALID_SIGNATURE: return "INVALID_SIGNATURE"; case INVALID_TIMESTAMP: return "INVALID_TIMESTAMP"; @@ -102,7 +103,6 @@ std::string pooling_error_e::to_string_value() const { case PARTIAL_TOO_LATE: return "PARTIAL_TOO_LATE"; case POOL_LOST_SYNC: return "POOL_LOST_SYNC"; case SERVER_ERROR: return "SERVER_ERROR"; - case UNKNOWN_FARMER: return "UNKNOWN_FARMER"; } return std::to_string(value); } @@ -116,6 +116,7 @@ std::string pooling_error_e::to_string_value_full() const { case INVALID_AUTH_KEY: return "mmx.pooling_error_e.INVALID_AUTH_KEY"; case INVALID_CONTRACT: return "mmx.pooling_error_e.INVALID_CONTRACT"; case INVALID_DIFFICULTY: return "mmx.pooling_error_e.INVALID_DIFFICULTY"; + case INVALID_PARTIAL: return "mmx.pooling_error_e.INVALID_PARTIAL"; case INVALID_PROOF: return "mmx.pooling_error_e.INVALID_PROOF"; case INVALID_SIGNATURE: return "mmx.pooling_error_e.INVALID_SIGNATURE"; case INVALID_TIMESTAMP: return "mmx.pooling_error_e.INVALID_TIMESTAMP"; @@ -124,7 +125,6 @@ std::string pooling_error_e::to_string_value_full() const { case PARTIAL_TOO_LATE: return "mmx.pooling_error_e.PARTIAL_TOO_LATE"; case POOL_LOST_SYNC: return "mmx.pooling_error_e.POOL_LOST_SYNC"; case SERVER_ERROR: return "mmx.pooling_error_e.SERVER_ERROR"; - case UNKNOWN_FARMER: return "mmx.pooling_error_e.UNKNOWN_FARMER"; } return std::to_string(value); } @@ -146,6 +146,7 @@ void pooling_error_e::from_string_value(const std::string& _name) { else if(_name == "INVALID_AUTH_KEY") value = INVALID_AUTH_KEY; else if(_name == "INVALID_CONTRACT") value = INVALID_CONTRACT; else if(_name == "INVALID_DIFFICULTY") value = INVALID_DIFFICULTY; + else if(_name == "INVALID_PARTIAL") value = INVALID_PARTIAL; else if(_name == "INVALID_PROOF") value = INVALID_PROOF; else if(_name == "INVALID_SIGNATURE") value = INVALID_SIGNATURE; else if(_name == "INVALID_TIMESTAMP") value = INVALID_TIMESTAMP; @@ -154,7 +155,6 @@ void pooling_error_e::from_string_value(const std::string& _name) { else if(_name == "PARTIAL_TOO_LATE") value = PARTIAL_TOO_LATE; else if(_name == "POOL_LOST_SYNC") value = POOL_LOST_SYNC; else if(_name == "SERVER_ERROR") value = SERVER_ERROR; - else if(_name == "UNKNOWN_FARMER") value = UNKNOWN_FARMER; else value = enum_t(vnx::hash64(_name)); } else { value = enum_t(std::stoul(_name.c_str(), nullptr, 0)); @@ -171,6 +171,7 @@ void pooling_error_e::accept(vnx::Visitor& _visitor) const { case INVALID_AUTH_KEY: _name = "INVALID_AUTH_KEY"; break; case INVALID_CONTRACT: _name = "INVALID_CONTRACT"; break; case INVALID_DIFFICULTY: _name = "INVALID_DIFFICULTY"; break; + case INVALID_PARTIAL: _name = "INVALID_PARTIAL"; break; case INVALID_PROOF: _name = "INVALID_PROOF"; break; case INVALID_SIGNATURE: _name = "INVALID_SIGNATURE"; break; case INVALID_TIMESTAMP: _name = "INVALID_TIMESTAMP"; break; @@ -179,7 +180,6 @@ void pooling_error_e::accept(vnx::Visitor& _visitor) const { case PARTIAL_TOO_LATE: _name = "PARTIAL_TOO_LATE"; break; case POOL_LOST_SYNC: _name = "POOL_LOST_SYNC"; break; case SERVER_ERROR: _name = "SERVER_ERROR"; break; - case UNKNOWN_FARMER: _name = "UNKNOWN_FARMER"; break; } _visitor.enum_value(value, _name); } @@ -193,6 +193,7 @@ void pooling_error_e::write(std::ostream& _out) const { case INVALID_AUTH_KEY: _out << "\"INVALID_AUTH_KEY\""; break; case INVALID_CONTRACT: _out << "\"INVALID_CONTRACT\""; break; case INVALID_DIFFICULTY: _out << "\"INVALID_DIFFICULTY\""; break; + case INVALID_PARTIAL: _out << "\"INVALID_PARTIAL\""; break; case INVALID_PROOF: _out << "\"INVALID_PROOF\""; break; case INVALID_SIGNATURE: _out << "\"INVALID_SIGNATURE\""; break; case INVALID_TIMESTAMP: _out << "\"INVALID_TIMESTAMP\""; break; @@ -201,7 +202,6 @@ void pooling_error_e::write(std::ostream& _out) const { case PARTIAL_TOO_LATE: _out << "\"PARTIAL_TOO_LATE\""; break; case POOL_LOST_SYNC: _out << "\"POOL_LOST_SYNC\""; break; case SERVER_ERROR: _out << "\"SERVER_ERROR\""; break; - case UNKNOWN_FARMER: _out << "\"UNKNOWN_FARMER\""; break; default: _out << value; } } @@ -262,7 +262,7 @@ std::shared_ptr pooling_error_e::static_create_type_code() { auto type_code = std::make_shared(); type_code->name = "mmx.pooling_error_e"; type_code->type_hash = vnx::Hash64(0xec786b877a93f17ull); - type_code->code_hash = vnx::Hash64(0xbcf2569e7ac5f81eull); + type_code->code_hash = vnx::Hash64(0x67403d1659447023ull); type_code->is_native = true; type_code->is_enum = true; type_code->native_size = sizeof(::mmx::pooling_error_e); @@ -274,22 +274,22 @@ std::shared_ptr pooling_error_e::static_create_type_code() { field.name = "value"; field.code = {3}; } - type_code->enum_map[3] = "CHALLENGE_NOT_FOUND"; - type_code->enum_map[1] = "CHALLENGE_REVERTED"; - type_code->enum_map[17] = "DUPLICATE_PARTIAL"; - type_code->enum_map[13] = "INVALID_ACCOUNT"; - type_code->enum_map[12] = "INVALID_AUTH_KEY"; - type_code->enum_map[9] = "INVALID_CONTRACT"; - type_code->enum_map[6] = "INVALID_DIFFICULTY"; - type_code->enum_map[4] = "INVALID_PROOF"; - type_code->enum_map[7] = "INVALID_SIGNATURE"; - type_code->enum_map[15] = "INVALID_TIMESTAMP"; + type_code->enum_map[471927302] = "CHALLENGE_NOT_FOUND"; + type_code->enum_map[1760085717] = "CHALLENGE_REVERTED"; + type_code->enum_map[271202490] = "DUPLICATE_PARTIAL"; + type_code->enum_map[3369359198] = "INVALID_ACCOUNT"; + type_code->enum_map[1953340654] = "INVALID_AUTH_KEY"; + type_code->enum_map[914919857] = "INVALID_CONTRACT"; + type_code->enum_map[1883406896] = "INVALID_DIFFICULTY"; + type_code->enum_map[405897781] = "INVALID_PARTIAL"; + type_code->enum_map[3117556933] = "INVALID_PROOF"; + type_code->enum_map[3529800621] = "INVALID_SIGNATURE"; + type_code->enum_map[2157722321] = "INVALID_TIMESTAMP"; type_code->enum_map[0] = "NONE"; - type_code->enum_map[5] = "PARTIAL_NOT_GOOD_ENOUGH"; - type_code->enum_map[2] = "PARTIAL_TOO_LATE"; - type_code->enum_map[16] = "POOL_LOST_SYNC"; - type_code->enum_map[8] = "SERVER_ERROR"; - type_code->enum_map[10] = "UNKNOWN_FARMER"; + type_code->enum_map[1161496011] = "PARTIAL_NOT_GOOD_ENOUGH"; + type_code->enum_map[2832488076] = "PARTIAL_TOO_LATE"; + type_code->enum_map[1324712875] = "POOL_LOST_SYNC"; + type_code->enum_map[2095599592] = "SERVER_ERROR"; type_code->build(); return type_code; } diff --git a/generated/src/pooling_stats_t.cpp b/generated/src/pooling_stats_t.cpp index 6056c1b2c..dbae953fa 100644 --- a/generated/src/pooling_stats_t.cpp +++ b/generated/src/pooling_stats_t.cpp @@ -12,7 +12,7 @@ namespace mmx { const vnx::Hash64 pooling_stats_t::VNX_TYPE_HASH(0xb2441a254359df11ull); -const vnx::Hash64 pooling_stats_t::VNX_CODE_HASH(0xc4b1a2cb298c781cull); +const vnx::Hash64 pooling_stats_t::VNX_CODE_HASH(0x7a7a16d5a8e52289ull); vnx::Hash64 pooling_stats_t::get_type_hash() const { return VNX_TYPE_HASH; @@ -49,7 +49,9 @@ void pooling_stats_t::accept(vnx::Visitor& _visitor) const { _visitor.type_field(_type_code->fields[1], 1); vnx::accept(_visitor, partial_diff); _visitor.type_field(_type_code->fields[2], 2); vnx::accept(_visitor, valid_points); _visitor.type_field(_type_code->fields[3], 3); vnx::accept(_visitor, failed_points); - _visitor.type_field(_type_code->fields[4], 4); vnx::accept(_visitor, error_count); + _visitor.type_field(_type_code->fields[4], 4); vnx::accept(_visitor, total_partials); + _visitor.type_field(_type_code->fields[5], 5); vnx::accept(_visitor, total_response_time); + _visitor.type_field(_type_code->fields[6], 6); vnx::accept(_visitor, error_count); _visitor.type_end(*_type_code); } @@ -59,6 +61,8 @@ void pooling_stats_t::write(std::ostream& _out) const { _out << ", \"partial_diff\": "; vnx::write(_out, partial_diff); _out << ", \"valid_points\": "; vnx::write(_out, valid_points); _out << ", \"failed_points\": "; vnx::write(_out, failed_points); + _out << ", \"total_partials\": "; vnx::write(_out, total_partials); + _out << ", \"total_response_time\": "; vnx::write(_out, total_response_time); _out << ", \"error_count\": "; vnx::write(_out, error_count); _out << "}"; } @@ -76,6 +80,8 @@ vnx::Object pooling_stats_t::to_object() const { _object["partial_diff"] = partial_diff; _object["valid_points"] = valid_points; _object["failed_points"] = failed_points; + _object["total_partials"] = total_partials; + _object["total_response_time"] = total_response_time; _object["error_count"] = error_count; return _object; } @@ -90,6 +96,10 @@ void pooling_stats_t::from_object(const vnx::Object& _object) { _entry.second.to(partial_diff); } else if(_entry.first == "server_url") { _entry.second.to(server_url); + } else if(_entry.first == "total_partials") { + _entry.second.to(total_partials); + } else if(_entry.first == "total_response_time") { + _entry.second.to(total_response_time); } else if(_entry.first == "valid_points") { _entry.second.to(valid_points); } @@ -109,6 +119,12 @@ vnx::Variant pooling_stats_t::get_field(const std::string& _name) const { if(_name == "failed_points") { return vnx::Variant(failed_points); } + if(_name == "total_partials") { + return vnx::Variant(total_partials); + } + if(_name == "total_response_time") { + return vnx::Variant(total_response_time); + } if(_name == "error_count") { return vnx::Variant(error_count); } @@ -124,6 +140,10 @@ void pooling_stats_t::set_field(const std::string& _name, const vnx::Variant& _v _value.to(valid_points); } else if(_name == "failed_points") { _value.to(failed_points); + } else if(_name == "total_partials") { + _value.to(total_partials); + } else if(_name == "total_response_time") { + _value.to(total_response_time); } else if(_name == "error_count") { _value.to(error_count); } @@ -153,13 +173,13 @@ std::shared_ptr pooling_stats_t::static_create_type_code() { auto type_code = std::make_shared(); type_code->name = "mmx.pooling_stats_t"; type_code->type_hash = vnx::Hash64(0xb2441a254359df11ull); - type_code->code_hash = vnx::Hash64(0xc4b1a2cb298c781cull); + type_code->code_hash = vnx::Hash64(0x7a7a16d5a8e52289ull); type_code->is_native = true; type_code->native_size = sizeof(::mmx::pooling_stats_t); type_code->create_value = []() -> std::shared_ptr { return std::make_shared>(); }; type_code->depends.resize(1); type_code->depends[0] = ::mmx::pooling_error_e::static_get_type_code(); - type_code->fields.resize(5); + type_code->fields.resize(7); { auto& field = type_code->fields[0]; field.is_extended = true; @@ -186,6 +206,18 @@ std::shared_ptr pooling_stats_t::static_create_type_code() { } { auto& field = type_code->fields[4]; + field.data_size = 4; + field.name = "total_partials"; + field.code = {3}; + } + { + auto& field = type_code->fields[5]; + field.data_size = 8; + field.name = "total_response_time"; + field.code = {8}; + } + { + auto& field = type_code->fields[6]; field.is_extended = true; field.name = "error_count"; field.code = {13, 4, 19, 0, 3}; @@ -241,11 +273,17 @@ void read(TypeInput& in, ::mmx::pooling_stats_t& value, const TypeCode* type_cod if(const auto* const _field = type_code->field_map[3]) { vnx::read_value(_buf + _field->offset, value.failed_points, _field->code.data()); } + if(const auto* const _field = type_code->field_map[4]) { + vnx::read_value(_buf + _field->offset, value.total_partials, _field->code.data()); + } + if(const auto* const _field = type_code->field_map[5]) { + vnx::read_value(_buf + _field->offset, value.total_response_time, _field->code.data()); + } } for(const auto* _field : type_code->ext_fields) { switch(_field->native_index) { case 0: vnx::read(in, value.server_url, type_code, _field->code.data()); break; - case 4: vnx::read(in, value.error_count, type_code, _field->code.data()); break; + case 6: vnx::read(in, value.error_count, type_code, _field->code.data()); break; default: vnx::skip(in, type_code, _field->code.data()); } } @@ -264,12 +302,14 @@ void write(TypeOutput& out, const ::mmx::pooling_stats_t& value, const TypeCode* else if(code && code[0] == CODE_STRUCT) { type_code = type_code->depends[code[1]]; } - auto* const _buf = out.write(24); + auto* const _buf = out.write(36); vnx::write_value(_buf + 0, value.partial_diff); vnx::write_value(_buf + 8, value.valid_points); vnx::write_value(_buf + 16, value.failed_points); + vnx::write_value(_buf + 24, value.total_partials); + vnx::write_value(_buf + 28, value.total_response_time); vnx::write(out, value.server_url, type_code, type_code->fields[0].code.data()); - vnx::write(out, value.error_count, type_code, type_code->fields[4].code.data()); + vnx::write(out, value.error_count, type_code, type_code->fields[6].code.data()); } void read(std::istream& in, ::mmx::pooling_stats_t& value) {