Allow rel_matcher_t to work with Fields of type double

[javafool]

I'm aware of the limitations in using rel_matcher_t for testing limits on double types, but I want to do it anyway. While attempting this, I noticed that the Field::extract(std::data(msg)) failed to extract the double from its field (field_matchers.hpp:189) properly. By changing the line to: msg.get(Field{}), the extraction was successful, and I could use rel_matcher_t for valid range checking on various double message fields (at least for my initial development). This extraction failure could be the intended behavior, forcing the use of a proper matcher that uses a small delta. Otherwise, I'm finding the library most useful. Thank you!

[elbeno]

Thanks for the report -

can you elaborate on the finding "Field::extract(std::data(msg)) failed to extract the double from its field (field_matchers.hpp:189) properly." ?

Do you have code that exhibits the problem?

[javafool]

In coming up with a simple example (which worked), I realized my original code was using pack<> for a reused header and the message-unique payload. When I split my simple example message and used pack<>, it failed to extract.

`#include <msg/callback.hpp>
#include <msg/field.hpp>
#include <msg/handler.hpp>
#include <msg/message.hpp>
#include <cib/cib.hpp>

#include

namespace simple_msg {

using namespace msg;

using field0_f = msg::field<"field0", uint16_t>::located<msg::at{15_msb, 0_lsb}>;
using field1_f = msg::field<"field1", uint16_t>::located<msg::at{31_msb, 16_lsb}>;
using field2_f = msg::field<"field2", uint32_t>::located<msg::at{63_msb, 32_lsb}>;
using field3_f = msg::field<"field3", double>::located<msg::at{127_msb, 64_lsb}>;

using msg_1_defn = message<"msg1",
field0_f,
field1_f
>;
using msg_2_defn = message<"msg2",
field2_f,
field3_f
>;

using msg_defn = pack<"msg", std::uint16_t, msg_1_defn, msg_2_defn>;

// -90 <= field3 <= 90 - individual expressions for testing
constexpr auto field1_match = msg::equal_to<field1_f, 1>;
constexpr auto field3_limit_min = msg::greater_than_or_equal_to<field3_f, 10.0>;
constexpr auto field3_limit_max = msg::less_than_or_equal_to<field3_f, 90.0>;
constexpr auto field3_limit_match = field3_limit_min and field3_limit_max;

} // namespace

using simple_msg_owned = msg::owning<simple_msg::msg_defn>;

// the message handler
struct simple_msg_handler : callback::service<simple_msg_owned> {
};

// service for message-specific information
struct get_simple_msg_t : public callback::service<> {};

struct simple_msg_run_t : public callback::service<> {};

using namespace msg::literals;

// the callback function
constexpr auto simple_msg_handler_cb = msg::callback<"simple_msg_handler",
simple_msg::msg_defn>
(
// verify predicates - sync bytes and message id at a minimum
simple_msg::field1_match and simple_msg::field3_limit_min,
[](auto msg)
{
std::cout << "simple message handler callback..." << std::endl;

  std::cout << "field0: " << msg.get("field0"_f) << std::endl;
  std::cout << "field1: " << msg.get("field1"_f) << std::endl;
  std::cout << "field2: " << msg.get("field2"_f) << std::endl;
  std::cout << "field3: " << msg.get("field3"_f) << std::endl;

}
);

// handler for the callback...
auto simple_msg_handler_cbs = stdx::make_tuple(simple_msg_handler_cb);

// instantiate a handler
auto h = msg::handler<decltype(simple_msg_handler_cbs),
simple_msg_owned>{simple_msg_handler_cbs};

// simple message handling component
struct simple_msg_component {
constexpr static auto simple_msg_feature =
[](simple_msg_owned data)
{
// handle data
std::cout << "Handling a simple message..." << std::endl;
h.handle(data);
};

constexpr static auto config = cib::config(

  // connects msg handler to this feature
  cib::exports<simple_msg_handler>,

  // extends get_version_response_type_t service with some functionality
  cib::extend<get_simple_msg_t>([] () {
 simple_msg_owned v_msg{};

 std::cout << "the character" << std::endl;

 char c;
 std::cin >> c;

 if (c == 'c') {
    exit(0);
 }

 v_msg.set("field0"_field = 0);
 v_msg.set("field1"_field = 1);
 v_msg.set("field2"_field = 1);
 v_msg.set("field3"_field = 45.5);

     cib::service<simple_msg_handler>(v_msg);
  }),

  // hooks the feature to the service
  cib::extend<simple_msg_handler>(simple_msg_feature),

  // perform any recurring actions before/after socket activity
  cib::extend<simple_msg_run_t>([]() { std::cout << "Enter a character (c to exit):\n"; })
  );

};

struct export_components_t {
constexpr static auto config =
cib::exports<get_simple_msg_t, simple_msg_run_t>;
};

struct dummy_project_t {
constexpr static auto config =
cib::components<simple_msg_component, export_components_t>;
};

static cib::nexus<dummy_project_t> nexus{};

int main() {

nexus.init(); // This is critical. otherwise accessing service from another
// service will result in the segmentation fault.

while (true) {
// Here both services will execute for every byte input.
nexus.service<simple_msg_run_t>();
nexus.service<get_simple_msg_t>();
}
return 0;
}
`
This resulted in the following output:
Enter a character (c to exit):
the character
e
Handling a simple message...
extract_field: 1
extract_field: 4.94066e-324
extract_field: 4.94066e-324
extract_field: 1
Enter a character (c to exit):
the character
c

I'd put a printf in field_matchers.hpp to get the 'extract_field' output.

So, worked fine on a 'regular' message, failed on the 'packed' message.

Thanks,
Jim

P.S. Say 'hi' to @mjcaisse for me.

[elbeno]

Thanks for the explanation.

This has nothing to do with double and everything to do with the field types (necessarily) changing/moving because of packing. It should be fixed with #762.

Basically, when you say

using msg_defn = pack<"msg", std::uint16_t, msg_1_defn, msg_2_defn>;

fields 2 and 3 (in msg_2_defn) have to move (this is what packing means after all). So it's incorrect to subsequently use matchers based on those fields - they're now looking in the wrong place.

(Side note here: above, you seem to be manually placing the fields so they don't collide, and then packing them -- you probably don't want that...)

So instead of saying:

constexpr auto field3_limit_min = msg::greater_than_or_equal_to<field3_f, 10.0>;

You can say instead:

constexpr auto field3_limit_min = msg::greater_than_or_equal_to<msg_defn::field_t<"field3">, 10.0>;

[javafool]

Great! Thanks for explanation and the fix - once I realized pack was the issue in my original code, my hasty change in the sample code didn't include resetting the bit 'counter' for the msg_2_defn fields.