[code] Clang-format

include/libremidi/backends/alsa_raw/midi_in.hpp

@@ -68,16 +68,19 @@ class midi_in_impl
 #if LIBREMIDI_ALSA_HAS_RAWMIDI_TREAD
     if (configuration.timestamps == timestamp_mode::NoTimestamp)
     {
-      if (const int err = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_STANDARD);
+      if (const int err
+          = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_STANDARD);
           err < 0)
         return err;
-      if (const int err = snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_NONE);
+      if (const int err
+          = snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_NONE);
           err < 0)
         return err;
     }
     else
     {
-      if (const int err = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_TSTAMP);
+      if (const int err
+          = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_TSTAMP);
           err < 0)
         return err;
       if (const int err

include/libremidi/backends/dummy.hpp

@@ -29,7 +29,10 @@ class midi_in_dummy final
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::DUMMY; }
-  bool open_port(const input_port& /*pt*/, std::string_view /*local_port_name*/) override { return true; }
+  bool open_port(const input_port& /*pt*/, std::string_view /*local_port_name*/) override
+  {
+    return true;
+  }
   bool open_virtual_port(std::string_view /*portName*/) override { return true; }
   void close_port() override { }
   void set_client_name(std::string_view /*clientName*/) override { }
@@ -47,7 +50,10 @@ class midi_out_dummy final
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::DUMMY; }
-  bool open_port(const output_port& /*pt*/, std::string_view /*local_port_name*/) override { return true; }
+  bool open_port(const output_port& /*pt*/, std::string_view /*local_port_name*/) override
+  {
+    return true;
+  }
   bool open_virtual_port(std::string_view /*portName*/) override { return true; }
   void close_port() override { }
   void set_client_name(std::string_view /*clientName*/) override { }

include/libremidi/backends/jack/helpers.hpp

@@ -61,7 +61,8 @@ struct jack_client
   }
 
   template <bool Input>
-  static auto get_ports(jack_client_t* client, const char* pattern, const JackPortFlags flags) noexcept
+  static auto
+  get_ports(jack_client_t* client, const char* pattern, const JackPortFlags flags) noexcept
       -> std::vector<std::conditional_t<Input, input_port, output_port>>
   {
     std::vector<std::conditional_t<Input, input_port, output_port>> ret;
@@ -214,7 +215,8 @@ struct jack_helpers : jack_client
     if (portName.empty())
       portName = flags & JackPortIsInput ? "i" : "o";
 
-    if (self.configuration.client_name.size() + portName.size() + 2u >= static_cast<size_t>(jack_port_name_size()))
+    if (self.configuration.client_name.size() + portName.size() + 2u
+        >= static_cast<size_t>(jack_port_name_size()))
     {
       self.template error<invalid_use_error>(
           self.configuration, "JACK: port name length limit exceeded");

include/libremidi/backends/jack/observer.hpp

@@ -186,7 +186,7 @@ class observer_jack final
     jack_set_port_rename_callback(
         this->client,
         +[](jack_port_id_t p, const char* /*old_name*/, const char* /*new_name*/, void* arg) {
-      const auto& self = *static_cast<observer_jack*>(arg);
+          const auto& self = *static_cast<observer_jack*>(arg);
 
           auto port = jack_port_by_id(self.client, p);
           if (!port)

include/libremidi/backends/linux/alsa.hpp

@@ -126,7 +126,7 @@ struct libasound
       LIBREMIDI_SYMBOL_DEF(snd_ctl_ump, endpoint_info);
       LIBREMIDI_SYMBOL_DEF(snd_ctl_ump, next_device);
     } ump;
-  #endif
+#endif
   } ctl{library};
 
   struct midi_t
@@ -222,7 +222,7 @@ struct libasound
     LIBREMIDI_SYMBOL_DEF(snd_rawmidi, tread);
     LIBREMIDI_SYMBOL_DEF(snd_rawmidi, write);
   } rawmidi{library};
-  #endif
+#endif
 
   struct seq_t
   {
@@ -371,7 +371,7 @@ struct libasound
       LIBREMIDI_SYMBOL_DEF(snd_seq_ump, event_input);
       LIBREMIDI_SYMBOL_DEF(snd_seq_ump, event_output);
     } ump;
-  #endif
+#endif
   } seq{library};
 
 #if LIBREMIDI_ALSA_HAS_UMP
@@ -417,34 +417,34 @@ struct libasound
     LIBREMIDI_SYMBOL_DEF(snd_ump, read);
     LIBREMIDI_SYMBOL_DEF(snd_ump, tread);
   } ump{library};
-  #endif
+#endif
 };
 
-  #undef snd_dylib_alloca
-  #define snd_dylib_alloca(ptr, access, type)                                \
-    {                                                                        \
-      *ptr = (snd_##access##_##type##_t*)alloca(snd.access.type##_sizeof()); \
-      memset(*ptr, 0, snd.access.type##_sizeof());                           \
-    }
-  #define snd_dylib_alloca2(ptr, access1, access2, type)                                         \
-    {                                                                                            \
-      *ptr = (snd_##access1##_access2##_##type##_t*)alloca(snd.access1.access2.type##_sizeof()); \
-      memset(*ptr, 0, snd.access1.access2.type##_sizeof());                                      \
-    }
+#undef snd_dylib_alloca
+#define snd_dylib_alloca(ptr, access, type)                                \
+  {                                                                        \
+    *ptr = (snd_##access##_##type##_t*)alloca(snd.access.type##_sizeof()); \
+    memset(*ptr, 0, snd.access.type##_sizeof());                           \
+  }
+#define snd_dylib_alloca2(ptr, access1, access2, type)                                         \
+  {                                                                                            \
+    *ptr = (snd_##access1##_access2##_##type##_t*)alloca(snd.access1.access2.type##_sizeof()); \
+    memset(*ptr, 0, snd.access1.access2.type##_sizeof());                                      \
+  }
 
-  #undef snd_rawmidi_info_alloca
-  #define snd_rawmidi_info_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, info)
-  #undef snd_rawmidi_params_alloca
-  #define snd_rawmidi_params_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, params)
-  #undef snd_rawmidi_status_alloca
-  #define snd_rawmidi_status_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, status)
-
-  #undef snd_seq_client_info_alloca
-  #define snd_seq_client_info_alloca(ptr) snd_dylib_alloca(ptr, seq, client_info)
-  #undef snd_seq_port_info_alloca
-  #define snd_seq_port_info_alloca(ptr) snd_dylib_alloca(ptr, seq, port_info)
-  #undef snd_seq_queue_tempo_alloca
-  #define snd_seq_queue_tempo_alloca(ptr) snd_dylib_alloca(ptr, seq, queue_tempo)
+#undef snd_rawmidi_info_alloca
+#define snd_rawmidi_info_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, info)
+#undef snd_rawmidi_params_alloca
+#define snd_rawmidi_params_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, params)
+#undef snd_rawmidi_status_alloca
+#define snd_rawmidi_status_alloca(ptr) snd_dylib_alloca(ptr, rawmidi, status)
+
+#undef snd_seq_client_info_alloca
+#define snd_seq_client_info_alloca(ptr) snd_dylib_alloca(ptr, seq, client_info)
+#undef snd_seq_port_info_alloca
+#define snd_seq_port_info_alloca(ptr) snd_dylib_alloca(ptr, seq, port_info)
+#undef snd_seq_queue_tempo_alloca
+#define snd_seq_queue_tempo_alloca(ptr) snd_dylib_alloca(ptr, seq, queue_tempo)
 
 #if LIBREMIDI_ALSA_HAS_UMP
   #undef snd_ump_block_info_alloca

include/libremidi/backends/winmm/helpers.hpp

@@ -36,7 +36,7 @@ inline std::string ConvertToUTF8(const TCHAR* str)
   if (length)
   {
     u8str.assign(static_cast<std::string::size_type>(length - 1), 0);
-    /*length =*/ WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &u8str[0], length, nullptr, nullptr);
+    /*length =*/WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &u8str[0], length, nullptr, nullptr);
   }
   return u8str;
 }

include/libremidi/backends/winmm/midi_in.hpp

@@ -64,8 +64,8 @@ class midi_in_winmm final
   bool do_open(unsigned int portNumber)
   {
     MMRESULT result = midiInOpen(
-        &this->inHandle, portNumber, std::bit_cast<DWORD_PTR>(&midiInputCallback), std::bit_cast<DWORD_PTR>(this),
-        CALLBACK_FUNCTION);
+        &this->inHandle, portNumber, std::bit_cast<DWORD_PTR>(&midiInputCallback),
+        std::bit_cast<DWORD_PTR>(this), CALLBACK_FUNCTION);
     if (result != MMSYSERR_NOERROR)
     {
       error<driver_error>(

include/libremidi/backends/winmm/observer.hpp

@@ -88,7 +88,7 @@ class observer_winmm : public observer_api
 
     if (portRemovedFunc)
     {
-      for (const auto &port : prevList)
+      for (const auto& port : prevList)
       {
         auto iter
             = std::ranges::find(currList, port.display_name, &port_information::display_name);

include/libremidi/detail/midi_out.hpp

@@ -18,7 +18,8 @@ class midi_out_api : public midi_api
   midi_out_api& operator=(const midi_out_api&) = delete;
   midi_out_api& operator=(midi_out_api&&) = delete;
 
-  [[nodiscard]] virtual bool open_port(const output_port& pt, std::string_view local_port_name) = 0;
+  [[nodiscard]] virtual bool open_port(const output_port& pt, std::string_view local_port_name)
+      = 0;
 
   [[nodiscard]] virtual int64_t current_time() const noexcept { return 0; }
 

include/libremidi/libremidi.cpp

@@ -164,19 +164,19 @@ std::any observer_default_configuration()
 namespace midi2
 {
 LIBREMIDI_INLINE
-    std::any in_default_configuration()
+std::any in_default_configuration()
 {
   return midi_in_configuration_for(default_api());
 }
 
 LIBREMIDI_INLINE
-    std::any out_default_configuration()
+std::any out_default_configuration()
 {
   return midi_out_configuration_for(default_api());
 }
 
 LIBREMIDI_INLINE
-    std::any observer_default_configuration()
+std::any observer_default_configuration()
 {
   return observer_configuration_for(default_api());
 }

include/libremidi/libremidi.hpp

@@ -80,7 +80,7 @@ class LIBREMIDI_EXPORT observer
   //! * api_conf can be an instance of observer_configuration,
   //!   such as jack_observer_configuration, winmm_observer_configuration, etc...
   //! * if no callbacks are passed, no secondary thread will be created unless absolutely necessary
-  explicit observer(const observer_configuration &conf = {}) noexcept;
+  explicit observer(const observer_configuration& conf = {}) noexcept;
   explicit observer(observer_configuration conf, std::any api_conf);
   observer(const observer&) = delete;
   observer(observer&& other) noexcept;
@@ -175,7 +175,8 @@ class LIBREMIDI_EXPORT midi_out
   [[nodiscard]] libremidi::API get_current_api() const noexcept;
 
   //! Open a MIDI output connection.
-  void open_port(const output_port& pt, std::string_view local_port_name = "libremidi input") const;
+  void
+  open_port(const output_port& pt, std::string_view local_port_name = "libremidi input") const;
 
   //! Close an open MIDI connection (if one exists).
   void close_port() const;

include/libremidi/message.hpp

@@ -231,7 +231,13 @@ struct meta_events
 
   static message tempo(int mpqn) noexcept
   {
-    return {0xff, 81, 3, static_cast<uint8_t>(mpqn >> 16), static_cast<uint8_t>(mpqn >> 8), static_cast<uint8_t>(mpqn)};
+    return {
+        0xff,
+        81,
+        3,
+        static_cast<uint8_t>(mpqn >> 16),
+        static_cast<uint8_t>(mpqn >> 8),
+        static_cast<uint8_t>(mpqn)};
   }
 
   static message time_signature(int numerator, int denominator)
@@ -245,7 +251,8 @@ struct meta_events
       ++powTwo;
     }
 
-    return {0xff, 0x58, 0x04, static_cast<uint8_t>(numerator), static_cast<uint8_t>(powTwo), 1, 96};
+    return {0xff, 0x58, 0x04, static_cast<uint8_t>(numerator), static_cast<uint8_t>(powTwo),
+            1,    96};
   }
 
   // Where key index goes from -7 (7 flats, C♭ Major) to +7 (7 sharps, C♯
@@ -256,12 +263,16 @@ struct meta_events
     if (keyIndex < -7 || keyIndex > 7)
       throw std::range_error("meta_events::key_signature: out of range");
 #endif
-    return {0xff, 0x59, 0x02, static_cast<uint8_t>(keyIndex), isMinor ? static_cast<uint8_t>(1) : static_cast<uint8_t>(0)};
+    return {
+        0xff, 0x59, 0x02, static_cast<uint8_t>(keyIndex),
+        isMinor ? static_cast<uint8_t>(1) : static_cast<uint8_t>(0)};
   }
 
   static message song_position(int positionInBeats) noexcept
   {
-    return {0xf2, static_cast<uint8_t>(positionInBeats & 127), static_cast<uint8_t>((positionInBeats >> 7) & 127)};
+    return {
+        0xf2, static_cast<uint8_t>(positionInBeats & 127),
+        static_cast<uint8_t>((positionInBeats >> 7) & 127)};
   }
 };
 

include/libremidi/midi_out.cpp

@@ -167,7 +167,7 @@ void midi_out::send_message(const unsigned char* message, size_t size) const
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(const uint32_t* message, size_t size) const
+void midi_out::send_ump(const uint32_t* message, size_t size) const
 {
 #if defined(LIBREMIDI_ASSERTIONS)
   assert(size > 0);
@@ -177,40 +177,39 @@ LIBREMIDI_INLINE
   impl_->send_ump(message, size);
 }
 LIBREMIDI_INLINE
-    void midi_out::send_ump(const libremidi::ump& message) const
+void midi_out::send_ump(const libremidi::ump& message) const
 {
   send_ump(message.bytes, message.size());
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(std::span<const uint32_t> message) const
+void midi_out::send_ump(std::span<const uint32_t> message) const
 {
   send_ump(message.data(), message.size());
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(uint32_t b0) const
+void midi_out::send_ump(uint32_t b0) const
 {
   send_ump(&b0, 1);
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(uint32_t b0, uint32_t b1) const
+void midi_out::send_ump(uint32_t b0, uint32_t b1) const
 {
   send_ump(std::to_array({b0, b1}));
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(uint32_t b0, uint32_t b1, uint32_t b2) const
+void midi_out::send_ump(uint32_t b0, uint32_t b1, uint32_t b2) const
 {
   send_ump(std::to_array({b0, b1, b2}));
 }
 
 LIBREMIDI_INLINE
-    void midi_out::send_ump(uint32_t b0, uint32_t b1, uint32_t b2, uint32_t b3) const
+void midi_out::send_ump(uint32_t b0, uint32_t b1, uint32_t b2, uint32_t b3) const
 {
   send_ump(std::to_array({b0, b1, b2, b3}));
 }
 
-
 }