Tidy up the midi2::ci namespace.

Move ci_message to the ci namespace and rename just "message". Remove
excess namespace qualifications. Move from_le7() etc./ and rename
to_array() as to_byte_array() etc.

Author: paulhuggett

demo/ci_discovery/ci_discovery.cpp

@@ -7,6 +7,7 @@
 //===------------------------------------------------------------------------------------===//
 
 #include <cstddef>
+#include <cstdlib>
 #include <format>
 #include <iostream>
 #include <iterator>
@@ -16,28 +17,28 @@
 #include "midi2/ci_types.hpp"
 #include "midi2/utils.hpp"
 
-namespace {
-
-auto discovery() {
-  constexpr midi2::ci::header hdr{
-      .device_id = 0x7F, .version = 2, .remote_muid = 0, .local_muid = midi2::ci::broadcast_muid};
-  constexpr midi2::ci::discovery discovery{.manufacturer = {0x12, 0x23, 0x34},
-                                           .family = 0x1779,
-                                           .model = 0x2B5D,
-                                           .version = {0x4E, 0x3C, 0x2A, 0x18},
-                                           .capability = 0x7F,
-                                           .max_sysex_size = 256,
-                                           .output_path_id = 0x71};
-  std::vector<std::byte> message;
-  midi2::ci::create_message(std::back_inserter(message), midi2::ci::trivial_sentinel{}, hdr, discovery);
-  return message;
-}
-
-}  // end anonymous namespace
-
 int main() {
-  for (auto const b : discovery()) {
+  constexpr std::size_t buffer_size = 256;
+  constexpr midi2::ci::header header{
+      .device_id = 0x7F, .version = 2, .remote_muid = 0, .local_muid = midi2::ci::broadcast_muid};
+  constexpr midi2::ci::discovery_reply discovery{.manufacturer = {0x12, 0x23, 0x34},
+                                                 .family = 0x1779,
+                                                 .model = 0x2B5D,
+                                                 .version = {0x4E, 0x3C, 0x2A, 0x18},
+                                                 .capability = 0x7F,
+                                                 .max_sysex_size = buffer_size,
+                                                 .output_path_id = 0};
+  std::array<std::byte, buffer_size> message{};
+  auto const first = std::begin(message);
+  auto const last = std::end(message);
+  auto const pos = midi2::ci::create_message(first, last, header, discovery);
+  if (pos == last) {
+    std::cerr << "Buffer too small\n";
+    return EXIT_FAILURE;
+  }
+  for (auto const b : std::ranges::subrange(first, pos)) {
     std::cout << std::format("{:02X} ", midi2::to_underlying(b));
   }
   std::cout << '\n';
+  return EXIT_SUCCESS;
 }

demo/ci_dispatcher/ci_dispatcher.cpp

@@ -5,18 +5,15 @@
 #include <ctime>
 #include <format>
 #include <iostream>
+#include <random>
+#include <ranges>
 
 namespace {
 
-consteval std::byte operator""_b(unsigned long long arg) noexcept {
-  assert(arg < 256);
-  return static_cast<std::byte>(arg);
-}
-
-template <typename Element, std::size_t Size> std::string as_string(std::array<Element, Size> const &arr) {
+template <std::ranges::input_range Range> std::string as_string(Range const &range) {
   std::string result;
   char const *separator = "";
-  for (auto const v : arr) {
+  for (auto const v : range) {
     result += std::format("{}0x{:X}", separator, v);
     separator = ", ";
   }
@@ -26,39 +23,41 @@ template <typename Element, std::size_t Size> std::string as_string(std::array<E
 }  // end anonymous namespace
 
 int main() {
-  try {
-    std::srand(static_cast<unsigned>(std::time(nullptr)));  // use current time as seed for random generator
-    auto const local_muid = std::uint32_t{static_cast<unsigned>(std::rand()) % midi2::ci::max_user_muid};
-
-    struct context {};
-    auto dispatcher = midi2::ci::make_function_dispatcher(context{});
-    dispatcher.config().system.on_check_muid(
-        [&local_muid](context, std::uint8_t /*group*/, std::uint32_t const muid) { return local_muid == muid; });
-    dispatcher.config().management.on_discovery(
-        [](context, midi2::ci::header const &hdr, midi2::ci::discovery const &d) {
-          std::cout << std::format("device-id=0x{:X}\nversion=0x{:X}\n", hdr.device_id, hdr.version)
-                    << std::format("remote-MUID=0x{:08X}\nlocal-MUID=0x{:08X}\n\n", hdr.remote_muid, hdr.local_muid);
-
-          std::cout << std::format("manufacturer=[{}]\nfamily=0x{:X}\nmodel=0x{:X}\n", as_string(d.manufacturer),
-                                   d.family, d.model)
-                    << std::format("version=[{}]\n", as_string(d.version))
-                    << std::format("capability=0x{:X}\nmax-sysex-size=0x{:X}\noutput-path-id=0x{:X}\n", d.capability,
-                                   d.max_sysex_size, d.output_path_id);
-        });
-
-    std::array const message{0x7E_b, 0x7F_b, 0x0D_b, 0x70_b, 0x02_b, 0x00_b, 0x00_b, 0x00_b, 0x00_b, 0x7F_b,
-                             0x7F_b, 0x7F_b, 0x7F_b, 0x12_b, 0x23_b, 0x34_b, 0x79_b, 0x2E_b, 0x5D_b, 0x56_b,
-                             0x4E_b, 0x3C_b, 0x2A_b, 0x18_b, 0x7F_b, 0x00_b, 0x02_b, 0x00_b, 0x00_b, 0x71_b};
-    constexpr auto group = std::uint8_t{0xFF};
-    constexpr auto device_id = 0x7F_b;
-    dispatcher.start(group, device_id);
-    for (auto const b : message) {
-      dispatcher.processMIDICI(b);
-    }
-    dispatcher.finish();
-  } catch (std::exception const &ex) {
-    std::cerr << "An error occurred: " << ex.what() << '\n';
-  } catch (...) {
-    std::cerr << "An unknown error occurred\n";
+  // Generate a random local MUID.
+  std::mt19937 engine{std::random_device{}()};
+  std::uniform_int_distribution<std::uint32_t> distribution;
+  auto const local_muid = distribution(engine) % midi2::ci::max_user_muid;
+
+  struct context {};
+  // Create a CI dispatcher instance using std::function<> for all of its handler functions.
+  auto dispatcher = midi2::ci::make_function_dispatcher(context{});
+  auto &config = dispatcher.config();
+  // Register a handler for checking whether a message is address to this MUID.
+  config.system.on_check_muid(
+      [&local_muid](context, std::uint8_t /*group*/, std::uint32_t const muid) { return local_muid == muid; });
+  // Register a handler for Discovery messages.
+  config.management.on_discovery([](context, midi2::ci::header const &hdr, midi2::ci::discovery const &d) {
+    // Display the header fields
+    std::cout << std::format("device-id=0x{:X}\nversion=0x{:X}\n", hdr.device_id, hdr.version)
+              << std::format("remote-MUID=0x{:08X}\nlocal-MUID=0x{:08X}\n\n", hdr.remote_muid, hdr.local_muid);
+
+    // Display the discovery data fields
+    std::cout << std::format("manufacturer=[{}]\nfamily=0x{:X}\nmodel=0x{:X}\n", as_string(d.manufacturer), d.family,
+                             d.model)
+              << std::format("version=[{}]\n", as_string(d.version))
+              << std::format("capability=0x{:X}\nmax-sysex-size=0x{:X}\noutput-path-id=0x{:X}\n", d.capability,
+                             d.max_sysex_size, d.output_path_id);
+    // Send a reply to this message...
+  });
+
+  constexpr std::array message{0x7E, 0x7F, 0x0D, 0x70, 0x02, 0x00, 0x00, 0x00, 0x00, 0x7F,
+                               0x7F, 0x7F, 0x7F, 0x12, 0x23, 0x34, 0x79, 0x2E, 0x5D, 0x56,
+                               0x4E, 0x3C, 0x2A, 0x18, 0x7F, 0x00, 0x02, 0x00, 0x00, 0x71};
+  constexpr auto group = std::uint8_t{0};
+  constexpr auto device_id = std::byte{0};
+  dispatcher.start(group, device_id);
+  for (auto const b : message) {
+    dispatcher.processMIDICI(static_cast<std::byte>(b));
   }
+  dispatcher.finish();
 }

include/midi2/ci_create_message.hpp

@@ -28,143 +28,143 @@ template <typename T> struct type_to_packed {};
 struct empty {};
 struct not_available {};
 template <> struct type_to_packed<discovery> {
-  static constexpr auto id = ci_message::discovery;
+  static constexpr auto id = message::discovery;
   using v1 = packed::discovery_v1;
   using v2 = packed::discovery_v2;
 };
 template <> struct type_to_packed<discovery_reply> {
-  static constexpr auto id = ci_message::discovery_reply;
+  static constexpr auto id = message::discovery_reply;
   using v1 = packed::discovery_reply_v1;
   using v2 = packed::discovery_reply_v2;
 };
 template <> struct type_to_packed<endpoint_info> {
-  static constexpr auto id = ci_message::endpoint_info;
+  static constexpr auto id = message::endpoint_info;
   using v1 = packed::endpoint_info_v1;
   using v2 = packed::endpoint_info_v1;
 };
 template <> struct type_to_packed<endpoint_info_reply> {
-  static constexpr auto id = ci_message::endpoint_info_reply;
+  static constexpr auto id = message::endpoint_info_reply;
 };
 template <> struct type_to_packed<invalidate_muid> {
-  static constexpr auto id = ci_message::invalidate_muid;
+  static constexpr auto id = message::invalidate_muid;
   using v1 = packed::invalidate_muid_v1;
   using v2 = packed::invalidate_muid_v1;
 };
 template <> struct type_to_packed<ack> {
-  static constexpr auto id = ci_message::ack;
+  static constexpr auto id = message::ack;
 };
 template <> struct type_to_packed<nak> {
-  static constexpr auto id = ci_message::nak;
+  static constexpr auto id = message::nak;
   using v1 = empty;
   using v2 = packed::nak_v2;
 };
 template <> struct type_to_packed<profile_configuration::added> {
-  static constexpr auto id = ci_message::profile_added;
+  static constexpr auto id = message::profile_added;
   using v1 = profile_configuration::packed::added_v1;
   using v2 = profile_configuration::packed::added_v1;
 };
 template <> struct type_to_packed<profile_configuration::removed> {
-  static constexpr auto id = ci_message::profile_removed;
+  static constexpr auto id = message::profile_removed;
   using v1 = profile_configuration::packed::removed_v1;
   using v2 = profile_configuration::packed::removed_v1;
 };
 template <> struct type_to_packed<profile_configuration::details> {
-  static constexpr auto id = ci_message::profile_details;
+  static constexpr auto id = message::profile_details;
   using v1 = profile_configuration::packed::details_v1;
   using v2 = profile_configuration::packed::details_v1;
 };
 template <> struct type_to_packed<profile_configuration::details_reply> {
-  static constexpr auto id = ci_message::profile_details_reply;
+  static constexpr auto id = message::profile_details_reply;
   using v1 = profile_configuration::packed::details_reply_v1;
   using v2 = profile_configuration::packed::details_reply_v1;
 };
 template <> struct type_to_packed<profile_configuration::inquiry> {
-  static constexpr auto id = ci_message::profile_inquiry;
+  static constexpr auto id = message::profile_inquiry;
   using v1 = empty;
   using v2 = empty;
 };
 template <> struct type_to_packed<profile_configuration::inquiry_reply> {
-  static constexpr auto id = ci_message::profile_inquiry_reply;
+  static constexpr auto id = message::profile_inquiry_reply;
 };
 template <> struct type_to_packed<profile_configuration::on> {
-  static constexpr auto id = ci_message::profile_set_on;
+  static constexpr auto id = message::profile_set_on;
   using v1 = profile_configuration::packed::on_v1;
   using v2 = profile_configuration::packed::on_v2;
 };
 template <> struct type_to_packed<profile_configuration::off> {
-  static constexpr auto id = ci_message::profile_set_off;
+  static constexpr auto id = message::profile_set_off;
   using v1 = profile_configuration::packed::off_v1;
   using v2 = profile_configuration::packed::off_v2;
 };
 template <> struct type_to_packed<profile_configuration::enabled> {
-  static constexpr auto id = ci_message::profile_enabled;
+  static constexpr auto id = message::profile_enabled;
   using v1 = profile_configuration::packed::enabled_v1;
   using v2 = profile_configuration::packed::enabled_v2;
 };
 template <> struct type_to_packed<profile_configuration::disabled> {
-  static constexpr auto id = ci_message::profile_disabled;
+  static constexpr auto id = message::profile_disabled;
   using v1 = profile_configuration::packed::disabled_v1;
   using v2 = profile_configuration::packed::disabled_v2;
 };
 template <> struct type_to_packed<profile_configuration::specific_data> {
-  static constexpr auto id = ci_message::profile_specific_data;
+  static constexpr auto id = message::profile_specific_data;
   using v1 = profile_configuration::packed::specific_data_v1;
   using v2 = profile_configuration::packed::specific_data_v1;
 };
 template <> struct type_to_packed<property_exchange::capabilities> {
-  static constexpr auto id = ci_message::pe_capability;
+  static constexpr auto id = message::pe_capability;
   using v1 = property_exchange::packed::capabilities_v1;
   using v2 = property_exchange::packed::capabilities_v2;
 };
 template <> struct type_to_packed<property_exchange::capabilities_reply> {
-  static constexpr auto id = ci_message::pe_capability_reply;
+  static constexpr auto id = message::pe_capability_reply;
   using v1 = property_exchange::packed::capabilities_reply_v1;
   using v2 = property_exchange::packed::capabilities_reply_v2;
 };
 template <> struct type_to_packed<property_exchange::get> {
-  static constexpr auto id = ci_message::pe_get;
+  static constexpr auto id = message::pe_get;
 };
 template <> struct type_to_packed<property_exchange::get_reply> {
-  static constexpr auto id = ci_message::pe_get_reply;
+  static constexpr auto id = message::pe_get_reply;
 };
 template <> struct type_to_packed<property_exchange::set> {
-  static constexpr auto id = ci_message::pe_set;
+  static constexpr auto id = message::pe_set;
 };
 template <> struct type_to_packed<property_exchange::set_reply> {
-  static constexpr auto id = ci_message::pe_set_reply;
+  static constexpr auto id = message::pe_set_reply;
 };
 template <> struct type_to_packed<property_exchange::subscription> {
-  static constexpr auto id = ci_message::pe_sub;
+  static constexpr auto id = message::pe_sub;
 };
 template <> struct type_to_packed<property_exchange::subscription_reply> {
-  static constexpr auto id = ci_message::pe_sub_reply;
+  static constexpr auto id = message::pe_sub_reply;
 };
 template <> struct type_to_packed<property_exchange::notify> {
-  static constexpr auto id = ci_message::pe_notify;
+  static constexpr auto id = message::pe_notify;
 };
 
 template <> struct type_to_packed<process_inquiry::capabilities> {
-  static constexpr auto id = ci_message::pi_capability;
+  static constexpr auto id = message::pi_capability;
   using v1 = empty;
   using v2 = empty;
 };
 template <> struct type_to_packed<process_inquiry::capabilities_reply> {
-  static constexpr auto id = ci_message::pi_capability_reply;
+  static constexpr auto id = message::pi_capability_reply;
   using v1 = not_available;
   using v2 = process_inquiry::packed::capabilities_reply_v2;
 };
 template <> struct type_to_packed<process_inquiry::midi_message_report> {
-  static constexpr auto id = ci_message::pi_mm_report;
+  static constexpr auto id = message::pi_mm_report;
   using v1 = not_available;
   using v2 = process_inquiry::packed::midi_message_report_v2;
 };
 template <> struct type_to_packed<process_inquiry::midi_message_report_reply> {
-  static constexpr auto id = ci_message::pi_mm_report_reply;
+  static constexpr auto id = message::pi_mm_report_reply;
   using v1 = not_available;
   using v2 = process_inquiry::packed::midi_message_report_reply_v2;
 };
 template <> struct type_to_packed<process_inquiry::midi_message_report_end> {
-  static constexpr auto id = ci_message::pi_mm_report_end;
+  static constexpr auto id = message::pi_mm_report_end;
   using v1 = not_available;
   using v2 = empty;
 };
@@ -197,7 +197,7 @@ constexpr O write_packed_with_tail(O first, S const last, std::byte const *ptr,
 }
 
 template <std::output_iterator<std::byte> O, std::sentinel_for<O> S>
-constexpr O write_header(O first, S const last, struct header const &h, ci_message const id) {
+constexpr O write_header(O first, S const last, struct header const &h, message const id) {
   auto hdr = static_cast<packed::header>(h);
   hdr.sub_id_2 = static_cast<std::byte>(id);
   return details::safe_copy(first, last, hdr);
@@ -214,7 +214,7 @@ constexpr O write_header_body(O first, S const last, header const &hdr, Internal
 
 template <std::output_iterator<std::byte> O, std::sentinel_for<O> S, property_exchange::property_exchange_type Pet>
 constexpr O write_pe(O first, S const last, header const &hdr, property_exchange::property_exchange<Pet> const &pe,
-                     ci_message const id) {
+                     message const id) {
   first = details::write_header(first, last, hdr, id);
 
   using property_exchange::packed::property_exchange_pt1;