working on win32 uwp! and libremidi update

include/libremidi/backends/coremidi/midi_out.hpp

@@ -7,10 +7,11 @@ namespace libremidi
 {
 class midi_out_core final
     : public midi1::out_api
-    , private coremidi_data
+    , public coremidi_data
     , public error_handler
 {
 public:
+  using midi_api::client_open_;
   struct
       : output_configuration
       , coremidi_output_configuration
@@ -22,11 +23,14 @@ public:
   {
     if (auto result = init_client(configuration); result != noErr)
     {
-      error<driver_error>(
+      libremidi_handle_error(
           this->configuration,
-          "midi_out_core: error creating MIDI client object: " + std::to_string(result));
+          "error creating MIDI client object: " + std::to_string(result));
+      client_open_ = from_osstatus(result);
       return;
     }
+
+    client_open_ = stdx::error{};
   }
 
   ~midi_out_core()
@@ -36,112 +40,79 @@ public:
     if (this->endpoint)
       MIDIEndpointDispose(this->endpoint);
 
-    close_client();
-  }
-
-  void close_client()
-  {
-    if (!configuration.context)
-      MIDIClientDispose(this->client);
-  }
-
-  void set_client_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_core: set_client_name unsupported");
-  }
-  void set_port_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_core: set_port_name unsupported");
+    close_client(*this);
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::COREMIDI; }
 
-  bool open_port(const output_port& info, std::string_view portName) override
+  stdx::error open_port(const output_port& info, std::string_view portName) override
   {
     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, false);
 
     // Find where we want to send
     auto destination = locate_object(*this, info, kMIDIObjectType_Destination);
     if (destination == 0)
-      return false;
+      return std::errc::invalid_argument;
 
     // Create our local source
     MIDIPortRef port;
     OSStatus result = MIDIOutputPortCreate(this->client, toCFString(portName).get(), &port);
     if (result != noErr)
     {
-      close_client();
-      error<driver_error>(
-          this->configuration, "midi_out_core::open_port: error creating macOS MIDI output port.");
-      return false;
+      close_client(*this);
+      libremidi_handle_error(
+          this->configuration, "error creating macOS MIDI output port.");
+      return from_osstatus(result);
     }
 
     // Save our api-specific connection information.
     this->port = port;
     this->destinationId = destination;
 
-    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 (this->endpoint)
-    {
-      warning(
-          configuration,
-          "midi_out_core::open_virtual_port: a virtual output port already "
-          "exists!");
-      return false;
-    }
-
     // Create a virtual MIDI output source.
     MIDIEndpointRef endpoint;
     OSStatus result = MIDISourceCreate(this->client, toCFString(portName).get(), &endpoint);
 
     if (result != noErr)
     {
-      error<driver_error>(
+      libremidi_handle_error(
           this->configuration,
-          "midi_out_core::initialize: error creating macOS virtual MIDI source.");
-      return false;
+          "error creating macOS virtual MIDI source.");
+
+      return from_osstatus(result);
     }
 
     // Save our api-specific connection information.
     this->endpoint = endpoint;
-    return true;
+    return stdx::error{};
   }
 
-  void close_port() override
+  stdx::error close_port() override
   {
-    if (this->endpoint)
-    {
-      MIDIEndpointDispose(this->endpoint);
-      this->endpoint = 0;
-    }
-
-    if (this->port)
-    {
-      MIDIPortDispose(this->port);
-      this->port = 0;
-    }
+    return coremidi_data::close_port();
   }
 
-  void send_message(const unsigned char* message, size_t size) override
+  stdx::error send_message(const unsigned char* message, size_t size) override
   {
     unsigned int nBytes = static_cast<unsigned int>(size);
     if (nBytes == 0)
     {
-      warning(configuration, "midi_out_core::send_message: no data in message argument!");
-      return;
+      libremidi_handle_warning(configuration, "no data in message argument!");
+      return std::errc::invalid_argument;
     }
 
     if (message[0] != 0xF0 && nBytes > 3)
     {
-      warning(
+      libremidi_handle_warning(
           configuration,
-          "midi_out_core::send_message: message format problem ... not sysex but "
+          "message format problem ... not sysex but "
           "> 3 bytes?");
-      return;
+      return std::errc::bad_message;
     }
 
     const MIDITimeStamp timestamp = LIBREMIDI_AUDIO_GET_CURRENT_HOST_TIME();
@@ -166,9 +137,10 @@ public:
 
       if (!packet)
       {
-        error<driver_error>(
-            this->configuration, "midi_out_core::send_message: could not allocate packet list");
-        return;
+        libremidi_handle_error(
+            this->configuration, "could not allocate packet list");
+
+        return std::errc::message_size;
       }
 
       // Send to any destinations that may have connected to us.
@@ -177,10 +149,11 @@ public:
         auto result = MIDIReceived(this->endpoint, packetList);
         if (result != noErr)
         {
-          warning(
+          libremidi_handle_warning(
               this->configuration,
-              "midi_out_core::send_message: error sending MIDI to virtual "
+              "error sending MIDI to virtual "
               "destinations.");
+          return std::errc::io_error;
         }
       }
 
@@ -190,12 +163,14 @@ public:
         auto result = MIDISend(this->port, this->destinationId, packetList);
         if (result != noErr)
         {
-          warning(
+          libremidi_handle_warning(
               this->configuration,
-              "midi_out_core::send_message: error sending MIDI message to port.");
+              "error sending MIDI message to port.");
+          return std::errc::io_error;
         }
       }
     }
+    return stdx::error{};
   }
 
   MIDIEndpointRef destinationId{};