Skip to content

Add message environments #702

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Mar 6, 2025
Merged

Add message environments #702

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
aba9fc1
:sparkles: Add environments for message definitions
elbeno Mar 5, 2025
0858891
:sparkles: Use message environment when logging callback matches
elbeno Mar 5, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ include(cmake/string_catalog.cmake)
add_versioned_package("gh:boostorg/mp11#boost-1.83.0")
fmt_recipe(11.1.3)
add_versioned_package("gh:intel/cpp-baremetal-concurrency#7c5b26c")
add_versioned_package("gh:intel/cpp-std-extensions#ec95cd6")
add_versioned_package("gh:intel/cpp-std-extensions#7725142")
add_versioned_package("gh:intel/cpp-baremetal-senders-and-receivers#73d95bc")

set(GEN_STR_CATALOG
Expand Down
12 changes: 12 additions & 0 deletions include/log/env.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,13 +18,25 @@ using cib_log_env_t = stdx::env<>;
return stdx::extend_env_t<cib_log_env_t, __VA_ARGS__>{}; \
}()) cib_log_env_t

#define CIB_APPEND_LOG_ENV_DECL(E) \
[[maybe_unused]] typedef decltype([] { \
return stdx::append_env_t<cib_log_env_t, E>{}; \
}()) cib_log_env_t

#define CIB_LOG_ENV(...) \
STDX_PRAGMA(diagnostic push) \
STDX_PRAGMA(diagnostic ignored "-Wshadow") \
CIB_LOG_ENV_DECL(__VA_ARGS__) \
CIB_PRAGMA_SEMI \
STDX_PRAGMA(diagnostic pop)

#define CIB_APPEND_LOG_ENV(E) \
STDX_PRAGMA(diagnostic push) \
STDX_PRAGMA(diagnostic ignored "-Wshadow") \
CIB_APPEND_LOG_ENV_DECL(E) \
CIB_PRAGMA_SEMI \
STDX_PRAGMA(diagnostic pop)

#define CIB_WITH_LOG_ENV(...) \
STDX_PRAGMA(diagnostic push) \
STDX_PRAGMA(diagnostic ignored "-Wshadow") \
Expand Down
31 changes: 19 additions & 12 deletions include/msg/callback.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,11 +29,13 @@ struct callback {

template <typename... Args>
[[nodiscard]] auto handle(auto const &data, Args &&...args) const -> bool {
CIB_LOG_ENV(logging::get_level, logging::level::INFO);
if (msg::call_with_message<Msg>(matcher, data)) {
CIB_INFO("Incoming message matched [{}], because [{}], executing "
"callback",
stdx::ct_string_to_type<Name, sc::string_constant>(),
matcher.describe());
CIB_APPEND_LOG_ENV(typename Msg::env_t);
CIB_LOG("Incoming message matched [{}], because [{}], executing "
"callback",
stdx::ct_string_to_type<Name, sc::string_constant>(),
matcher.describe());
msg::call_with_message<Msg>(callable, data,
std::forward<Args>(args)...);
return true;
Expand All @@ -42,14 +44,19 @@ struct callback {
}

auto log_mismatch(auto const &data) const -> void {
CIB_INFO(" {} - F:({})",
stdx::ct_string_to_type<Name, sc::string_constant>(),
msg::call_with_message<Msg>(
[&]<typename T>(T &&t) -> decltype(matcher.describe_match(
std::forward<T>(t))) {
return matcher.describe_match(std::forward<T>(t));
},
data));
CIB_LOG_ENV(logging::get_level, logging::level::INFO);
{
CIB_APPEND_LOG_ENV(typename Msg::env_t);
CIB_LOG(
" {} - F:({})",
stdx::ct_string_to_type<Name, sc::string_constant>(),
msg::call_with_message<Msg>(
[&]<typename T>(T &&t) -> decltype(matcher.describe_match(
std::forward<T>(t))) {
return matcher.describe_match(std::forward<T>(t));
},
data));
}
}

using msg_t = Msg;
Expand Down
11 changes: 6 additions & 5 deletions include/msg/detail/indexed_builder_common.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -163,12 +163,13 @@ struct indexed_builder_base {
}

using msg_t = typename CB::msg_t;
CIB_LOG_ENV(logging::get_level, logging::level::INFO);
if (msg::call_with_message<msg_t>(cb.matcher, data)) {
CIB_INFO(
"Incoming message matched [{}], because [{}] (collapsed to "
"[{}]), executing callback",
stdx::ct_string_to_type<cb.name, sc::string_constant>(),
orig_cb.matcher.describe(), cb.matcher.describe());
CIB_APPEND_LOG_ENV(typename msg_t::env_t);
CIB_LOG("Incoming message matched [{}], because [{}] (collapsed to "
"[{}]), executing callback",
stdx::ct_string_to_type<cb.name, sc::string_constant>(),
orig_cb.matcher.describe(), cb.matcher.describe());
msg::call_with_message<msg_t>(cb.callable, data, args...);
return true;
}
Expand Down
113 changes: 69 additions & 44 deletions include/msg/message.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@

#include <stdx/compiler.hpp>
#include <stdx/ct_string.hpp>
#include <stdx/cx_vector.hpp>
#include <stdx/env.hpp>
#include <stdx/iterator.hpp>
#include <stdx/ranges.hpp>
#include <stdx/span.hpp>
Expand Down Expand Up @@ -197,7 +197,7 @@ template <typename... Fields> struct storage_size {

template <typename F> using name_for = typename F::name_t;

template <stdx::ct_string Name, typename... Fields> class message_access {
template <stdx::ct_string Name, typename... Fields> class msg_access {
using FieldsTuple =
decltype(stdx::make_indexed_tuple<name_for>(Fields{}...));

Expand Down Expand Up @@ -295,10 +295,11 @@ concept storage_like = stdx::range<T> and requires {
typename T::value_type;
};

template <stdx::ct_string Name, typename... Fields> struct message;
template <stdx::ct_string Name, typename Env, typename... Fields>
struct message;

template <stdx::ct_string Name> struct msg_q {
template <typename... Fields> using fn = message<Name, Fields...>;
template <stdx::ct_string Name, typename Env> struct msg_q {
template <typename... Fields> using fn = message<Name, Env, Fields...>;
};

template <typename F1, typename F2>
Expand All @@ -312,9 +313,9 @@ using unique_by_name = boost::mp11::mp_unique_if<
boost::mp11::mp_sort<boost::mp11::mp_list<Fields...>, field_sort_fn>,
name_equal_fn>;

template <stdx::ct_string Name, typename... Fields>
template <stdx::ct_string Name, typename Env, typename... Fields>
using message_without_unique_field_names =
boost::mp11::mp_apply_q<detail::msg_q<Name>,
boost::mp11::mp_apply_q<detail::msg_q<Name, Env>,
detail::unique_by_name<Fields...>>;

template <stdx::ct_string Name, typename... Fields>
Expand All @@ -323,12 +324,45 @@ struct message_with_unique_field_names {
name_for, boost::mp11::mp_list<Fields...>>>::value,
"Message contains fields with duplicate names");

using type = message_without_unique_field_names<Name, Fields...>;
using type =
message_without_unique_field_names<Name, stdx::env<>, Fields...>;
};

template <stdx::ct_string Name, stdx::envlike Env, typename... Fields>
struct message_with_unique_field_names<Name, Env, Fields...> {
static_assert(boost::mp11::mp_is_set<boost::mp11::mp_transform<
name_for, boost::mp11::mp_list<Fields...>>>::value,
"Message contains fields with duplicate names");

using type = message_without_unique_field_names<Name, Env, Fields...>;
};

template <stdx::ct_string Name, typename... Fields> struct message {
template <stdx::ct_string Name, typename Access, typename T> struct msg_base {
constexpr static auto name = Name;

constexpr auto as_derived() const -> T const & {
return static_cast<T const &>(*this);
}
constexpr auto as_derived() -> T & { return static_cast<T &>(*this); }

[[nodiscard]] constexpr auto get(auto f) const {
return Access::get(as_derived().data(), f);
}
constexpr auto set(auto... fs) -> void {
Access::set(as_derived().data(), fs...);
}
constexpr auto set() -> void {}

[[nodiscard]] constexpr auto describe() const {
return Access::describe(as_derived().data());
}
};

template <stdx::ct_string Name, typename Env, typename... Fields>
struct message {
using fields_t = stdx::type_list<Fields...>;
using access_t = detail::message_access<Name, Fields...>;
using env_t = Env;
using access_t = msg_access<Name, Fields...>;
using default_storage_t = typename access_t::default_storage_t;
using default_span_t = typename access_t::default_span_t;
using default_const_span_t = typename access_t::default_const_span_t;
Expand All @@ -342,32 +376,13 @@ template <stdx::ct_string Name, typename... Fields> struct message {

template <auto N, typename Unit = bit_unit>
using shifted_by =
message<Name, typename Fields::template shifted_by<N, Unit>...>;
message<Name, Env, typename Fields::template shifted_by<N, Unit>...>;

template <typename S>
constexpr static auto fits_inside =
(... and Fields::template fits_inside<S>());

template <typename T> struct base {
constexpr static auto name = Name;

constexpr auto as_derived() const -> T const & {
return static_cast<T const &>(*this);
}
constexpr auto as_derived() -> T & { return static_cast<T &>(*this); }

[[nodiscard]] constexpr auto get(auto f) const {
return access_t::get(as_derived().data(), f);
}
constexpr auto set(auto... fs) -> void {
access_t::set(as_derived().data(), fs...);
}
constexpr auto set() -> void {}

[[nodiscard]] constexpr auto describe() const {
return access_t::describe(as_derived().data());
}
};
template <typename T> using base = msg_base<Name, access_t, T>;

template <typename> struct owner_t;

Expand Down Expand Up @@ -583,13 +598,17 @@ template <stdx::ct_string Name, typename... Fields> struct message {
// name (see unique_by_name)
template <stdx::ct_string NewName, typename... NewFields>
using extension =
message_without_unique_field_names<NewName, NewFields..., Fields...>;
message_without_unique_field_names<NewName, Env, NewFields...,
Fields...>;

template <stdx::envlike E>
using with_env = message<Name, stdx::append_env_t<Env, E>, Fields...>;
};
} // namespace detail

template <stdx::ct_string Name, typename... Fields>
template <stdx::ct_string Name, typename... Ts>
using message =
typename detail::message_with_unique_field_names<Name, Fields...>::type;
typename detail::message_with_unique_field_names<Name, Ts...>::type;

template <typename T> using owning = typename T::template owner_t<>;
template <typename T> using mutable_view = typename T::mutable_view_t;
Expand Down Expand Up @@ -681,15 +700,16 @@ using shifted_msgs =
msg_offsets<AlignTo, Msgs...>,
stdx::type_list<Msgs..., msg::message<"end">>>;

template <stdx::ct_string Name> struct combiner {
template <typename... Fields> using fn = msg::message<Name, Fields...>;
template <stdx::ct_string Name, stdx::envlike Env> struct combiner {
template <typename... Fields> using fn = msg::message<Name, Env, Fields...>;
};

template <stdx::ct_string Name> struct combine_q {
template <typename... Msgs>
requires(sizeof...(Msgs) > 0)
using fn = boost::mp11::mp_apply_q<
combiner<Name>, boost::mp11::mp_append<typename Msgs::fields_t...>>;
combiner<Name, stdx::append_env_t<typename Msgs::env_t...>>,
boost::mp11::mp_append<typename Msgs::fields_t...>>;
};
} // namespace detail

Expand All @@ -709,32 +729,37 @@ using is_locatable = std::bool_constant<requires { F::sort_key; }>;
template <typename F1, typename F2>
using field_size_sort_fn = std::bool_constant < F2::bitsize<F1::bitsize>;

template <stdx::ct_string Name, typename... Fields> struct field_locator {
template <stdx::ct_string Name, typename... Fields>
struct field_locator : field_locator<Name, stdx::env<>, Fields...> {};

template <stdx::ct_string Name, stdx::envlike Env, typename... Fields>
struct field_locator<Name, Env, Fields...> {
using fields = boost::mp11::mp_partition<boost::mp11::mp_list<Fields...>,
is_locatable>;
using located_fields = boost::mp11::mp_first<fields>;
using unlocated_fields = boost::mp11::mp_second<fields>;

using located_msg = boost::mp11::mp_apply_q<combiner<Name>, located_fields>;
using located_msg =
boost::mp11::mp_apply_q<combiner<Name, stdx::env<>>, located_fields>;

using auto_fields =
boost::mp11::mp_sort<unlocated_fields, field_size_sort_fn>;

template <typename F>
using as_singleton_message =
msg::message<Name, typename F::default_located>;
msg::message<Name, Env, typename F::default_located>;
using auto_msgs =
boost::mp11::mp_transform<as_singleton_message, auto_fields>;

using all_msgs = boost::mp11::mp_push_front<auto_msgs, located_msg>;

template <typename... Msgs>
using pack = msg::pack<Name, std::uint8_t, Msgs...>;
using msg_type = boost::mp11::mp_apply<pack, all_msgs>;
using msg_type =
typename boost::mp11::mp_apply<pack, all_msgs>::template with_env<Env>;
};
} // namespace detail

template <stdx::ct_string Name, typename... Fields>
using relaxed_message =
typename detail::field_locator<Name, Fields...>::msg_type;
template <stdx::ct_string Name, typename... Ts>
using relaxed_message = typename detail::field_locator<Name, Ts...>::msg_type;
} // namespace msg
18 changes: 17 additions & 1 deletion test/msg/callback.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -152,7 +152,7 @@ TEST_CASE("callback handles message (typed)", "[callback]") {
CHECK(dispatched);
}

TEST_CASE("callback logs match", "[callback]") {
TEST_CASE("callback logs match as INFO", "[callback]") {
auto callback = msg::callback<"cb", msg_defn>(
id_match, [](msg::const_view<msg_defn>) { dispatched = true; });
auto const msg_match = std::array{0x8000ba11u, 0x0042d00du};
Expand All @@ -162,6 +162,22 @@ TEST_CASE("callback logs match", "[callback]") {
CAPTURE(log_buffer);
CHECK(log_buffer.find("matched [cb], because [id == 0x80]") !=
std::string::npos);
CHECK(log_buffer.find("INFO") != std::string::npos);
}

TEST_CASE("callback logs match using message environment", "[callback]") {
using trace_msg_defn = msg_defn::with_env<
stdx::make_env_t<logging::get_level, logging::level::TRACE>>;
auto callback = msg::callback<"cb", trace_msg_defn>(
id_match, [](msg::const_view<trace_msg_defn>) { dispatched = true; });
auto const msg_match = std::array{0x8000ba11u, 0x0042d00du};

log_buffer.clear();
CHECK(callback.handle(msg_match));
CAPTURE(log_buffer);
CHECK(log_buffer.find("matched [cb], because [id == 0x80]") !=
std::string::npos);
CHECK(log_buffer.find("TRACE") != std::string::npos);
}

TEST_CASE("callback with convenience matcher", "[callback]") {
Expand Down
Loading
Loading