working on win32 uwp! and libremidi update

include/libremidi/backends/alsa_seq/midi_out.hpp

@@ -23,22 +23,21 @@ public:
   {
     if (init_client(configuration) < 0)
     {
-      error<driver_error>(
+      libremidi_handle_error(
           this->configuration,
-          "midi_in_alsa::initialize: error creating ALSA sequencer client "
+          "error creating ALSA sequencer client "
           "object.");
       return;
     }
 
     if (snd.midi.event_new(this->bufferSize, &this->coder) < 0)
     {
-      error<driver_error>(
-          this->configuration,
-          "midi_out_alsa::initialize: error initializing MIDI event "
-          "parser.");
+      libremidi_handle_error(this->configuration, "error initializing MIDI event parser.");
       return;
     }
     snd.midi.event_init(this->coder);
+
+    this->client_open_ = stdx::error{};
   }
 
   ~midi_out_impl() override
@@ -54,6 +53,8 @@ public:
 
     if (!configuration.context)
       snd.seq.close(this->seq);
+
+    client_open_ = std::errc::not_connected;
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_SEQ; }
@@ -65,55 +66,60 @@ public:
         SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION, std::nullopt);
   }
 
-  bool open_port(const output_port& p, std::string_view portName) override
+  stdx::error open_port(const output_port& p, std::string_view portName) override
   {
     unsigned int nSrc = this->get_port_count(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
     if (nSrc < 1)
     {
-      error<no_devices_found_error>(
-          this->configuration, "midi_out_alsa::open_port: no MIDI output sources found!");
-      return false;
+      libremidi_handle_error(this->configuration, "no MIDI output sources found!");
+      return make_error_code(std::errc::no_such_device);
     }
 
     auto sink = get_port_info(p);
     if (!sink)
-      return false;
+      return std::errc::invalid_argument;
 
     if (int err = create_port(portName); err < 0)
     {
-      error<driver_error>(configuration, "midi_out_alsa::create_port: ALSA error creating port.");
-      return false;
+      libremidi_handle_error(configuration, "ALSA error creating port.");
+      return from_errc(err);
     }
 
     snd_seq_addr_t source{
         .client = (unsigned char)snd.seq.client_id(this->seq), .port = (unsigned char)this->vport};
     if (int err = create_connection(*this, source, *sink, true); err < 0)
     {
-      error<driver_error>(
-          configuration, "midi_out_alsa::create_port: ALSA error making port connection.");
-      return false;
+      libremidi_handle_error(configuration, "ALSA error making port connection.");
+      return from_errc(err);
     }
 
-    return true;
+    return stdx::error{};
   }
 
-  bool open_virtual_port(std::string_view portName) override
+  stdx::error open_virtual_port(std::string_view portName) override
   {
     if (int err = create_port(portName); err < 0)
-      return false;
-    return true;
+      return from_errc(err);
+    return stdx::error{};
   }
 
-  void close_port() override { unsubscribe(); }
-
-  void set_client_name(std::string_view clientName) override
+  stdx::error close_port() override
   {
-    alsa_data::set_client_name(clientName);
+    unsubscribe();
+    return stdx::error{};
   }
 
-  void set_port_name(std::string_view portName) override { alsa_data::set_port_name(portName); }
+  stdx::error set_client_name(std::string_view clientName) override
+  {
+    return alsa_data::set_client_name(clientName);
+  }
 
-  void send_message(const unsigned char* message, std::size_t size) override
+  stdx::error set_port_name(std::string_view portName) override
+  {
+    return alsa_data::set_port_name(portName);
+  }
+
+  stdx::error send_message(const unsigned char* message, std::size_t size) override
   {
     int64_t result{};
     if (size > this->bufferSize)
@@ -122,11 +128,11 @@ public:
       result = snd.midi.event_resize_buffer(this->coder, size);
       if (result != 0)
       {
-        error<driver_error>(
+        libremidi_handle_error(
             this->configuration,
-            "midi_out_alsa::send_message: ALSA error resizing MIDI event "
+            "ALSA error resizing MIDI event "
             "buffer.");
-        return;
+        return std::errc::no_buffer_space;
       }
     }
 
@@ -144,14 +150,14 @@ public:
       result = snd.midi.event_encode(this->coder, message + offset, (long)(nBytes - offset), &ev);
       if (result < 0)
       {
-        warning(this->configuration, "midi_out_alsa::send_message: event parsing error!");
-        return;
+        libremidi_handle_warning(this->configuration, "event parsing error!");
+        return std::errc::bad_message;
       }
 
       if (ev.type == SND_SEQ_EVENT_NONE)
       {
-        warning(this->configuration, "midi_out_alsa::send_message: incomplete message!");
-        return;
+        libremidi_handle_warning(this->configuration, "incomplete message!");
+        return std::errc::message_size;
       }
 
       offset += result;
@@ -159,13 +165,12 @@ public:
       result = snd.seq.event_output(this->seq, &ev);
       if (result < 0)
       {
-        warning(
-            this->configuration,
-            "midi_out_alsa::send_message: error sending MIDI message to port.");
-        return;
+        libremidi_handle_warning(this->configuration, "error sending MIDI message to port.");
+        return std::errc::io_error;
       }
     }
     snd.seq.drain_output(this->seq);
+    return stdx::error{};
   }
 
 private: