LrIpcIn Class Reference

#include <LR_IPC_In.h>

Public Member Functions
	LrIpcIn (const LrIpcIn &other)=delete
	LrIpcIn (ControlsModel &c_model, ProfileManager &profile_manager, const Profile &profile, const MidiSender &midi_sender, asio::io_context &io_context)
	LrIpcIn (LrIpcIn &&other)=delete
	~LrIpcIn ()=default
LrIpcIn &	operator= (const LrIpcIn &other)=delete
LrIpcIn &	operator= (LrIpcIn &&other)=delete
void	Start ()
void	Stop ()

Private Member Functions
void	Connect (std::shared_ptr< LrIpcInShared > lr_ipc_shared)
void	ProcessLine (std::shared_ptr< LrIpcInShared > lr_ipc_shared)

Private Attributes
ControlsModel &	controls_model_
std::shared_ptr< LrIpcInShared >	lr_ipc_in_shared_
const MidiSender &	midi_sender_
std::future< void >	process_line_future_
const Profile &	profile_
ProfileManager &	profile_manager_

Constructor & Destructor Documentation

LrIpcIn() [1/3]

LrIpcIn::LrIpcIn	(	ControlsModel &	c_model,
		ProfileManager &	profile_manager,
		const Profile &	profile,
		const MidiSender &	midi_sender,
		asio::io_context &	io_context )

    : midi_sender_ {midi_sender}, profile_ {profile}, controls_model_ {c_model},
      profile_manager_ {profile_manager},
      lr_ipc_in_shared_ {std::make_shared<LrIpcInShared>(io_context)}
{
}

References midi_sender_.

~LrIpcIn()

LrIpcIn::~LrIpcIn ( )

default

LrIpcIn() [2/3]

LrIpcIn::LrIpcIn ( const LrIpcIn & other )

delete

LrIpcIn() [3/3]

LrIpcIn::LrIpcIn ( LrIpcIn && other )

delete

Member Function Documentation

Connect()

void LrIpcIn::Connect ( std::shared_ptr< LrIpcInShared > lr_ipc_shared )

private

{
   try {
      lr_ipc_shared->socket_.async_connect(asio::ip::tcp::endpoint(asio::ip::address_v4::loopback(),
                                               kLrInPort),
          [lr_ipc_shared](const asio::error_code& error) mutable {
         // capture a copy of the alive token so handler can detect owner shutdown
         const auto alive {lr_ipc_shared->owner_alive_};
         if (!alive || !alive->load(std::memory_order_acquire)) { return; }
 
         if (!error) {
            rsj::Log("Socket connected in LR_IPC_In.", std::source_location::current());
            // only proceed if owner still alive
            if (alive->load(std::memory_order_acquire)) {
               LrIpcInShared::Read(std::move(lr_ipc_shared));
            }
         }
         else {
            rsj::Log(fmt::format("LR_IPC_In did not connect. {}.", error.message()),
                std::source_location::current());
            asio::error_code ec2;
            std::ignore = lr_ipc_shared->socket_.close(ec2);
            if (ec2) {
               rsj::Log(fmt::format("LR_IPC_In socket close error {}.", ec2.message()),
                   std::source_location::current());
            }
         }
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Referenced by Start().

operator=() [1/2]

LrIpcIn & LrIpcIn::operator= ( const LrIpcIn & other )

delete

operator=() [2/2]

LrIpcIn & LrIpcIn::operator= ( LrIpcIn && other )

delete

ProcessLine()

void LrIpcIn::ProcessLine ( std::shared_ptr< LrIpcInShared > lr_ipc_shared )

private

{
   try {
      decltype(lr_ipc_shared->line_)::value_type line_copy;
      while ((line_copy = lr_ipc_shared->line_.pop()) != kTerminate) {
#pragma warning(suppress : 26445) /* copying views; otherwise dangling references */
         auto [command_view, value_view] {SplitLine(line_copy)};
 
         /* Fast path for known commands */
         if (command_view == "TerminateApplication") [[unlikely]] {
            if (auto* app = juce::JUCEApplication::getInstance()) { app->systemRequestedQuit(); }
            return;
         }
 
         if (value_view.empty()) [[unlikely]] {
            rsj::Log(fmt::format("No value attached to message. Message from plugin was \"{}\".",
                         rsj::ReplaceInvisibleChars(line_copy)),
                std::source_location::current());
            continue;
         }
 
         if (command_view == "SwitchProfile") {
            profile_manager_.SwitchToProfile(std::string(value_view));
            continue;
         }
 
         if (command_view == "Log") {
            rsj::Log(fmt::format("Plugin: {}.", value_view), std::source_location::current());
            continue;
         }
 
         if (command_view == "SendKey") {
            int modifiers {0};
            auto [ptr, ec] {std::from_chars(value_view.data(),
                value_view.data() + value_view.size(), modifiers)};
            /* Find the first non-digit after parsing modifiers */
            std::string_view key_view {value_view};
            key_view.remove_prefix(static_cast<size_t>(ptr - value_view.data()));
            if (!key_view.empty() && (key_view.front() == ' ' || key_view.front() == '\t')) {
               key_view.remove_prefix(1);
            }
            if (!key_view.empty() && ec == std::errc()) {
               rsj::SendKeyDownUp(std::string(key_view),
                   rsj::ActiveModifiers::FromMidi2LR(modifiers));
               continue;
            }
            rsj::LogAndAlertError(fmt::format("SendKey couldn't identify keystroke. Message from "
                                              "plugin was \"{}\".",
                                      rsj::ReplaceInvisibleChars(line_copy)),
                std::source_location::current());
            continue;
         }
 
         /* Default: send associated messages to MIDI OUT devices */
         double original_value {0.0};
#if defined(_MSC_VER) || (__MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_26_0)
         auto [ptr, ec] {std::from_chars(value_view.data(), value_view.data() + value_view.size(),
             original_value)};
         if (ec != std::errc()) {
            rsj::LogAndAlertError(fmt::format("Failed to parse double from \"{}\".", value_view),
                std::source_location::current());
            continue;
         }
#else
         try {
            original_value = std::stod(std::string(value_view));
         }
         catch (const std::exception& ex) {
            rsj::LogAndAlertError(fmt::format("Failed to parse double from \"{}\": {}", value_view,
                                      ex.what()),
                std::source_location::current());
            continue;
         }
#endif
         const auto messages {profile_.GetMessagesForCommand(std::string(command_view))};
         for (const auto& msg : messages) {
            const auto value {controls_model_.PluginToController(msg, original_value)};
            if (msg.msg_id_type != rsj::MessageType::kCc
                || controls_model_.GetCcMethod(msg) == rsj::CCmethod::kAbsolute) {
               midi_sender_.Send(msg, value);
            }
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References profile_, profile_manager_, and ProfileManager::SwitchToProfile().

Referenced by Start().

Start()

void LrIpcIn::Start

(

)

{
   try {
      process_line_future_ =
          std::async(std::launch::async, [this, shared = lr_ipc_in_shared_]() mutable {
         rsj::LabelThread(MIDI2LR_UC_LITERAL("LrIpcIn ProcessLine thread"));
         MIDI2LR_FAST_FLOATS;
         ProcessLine(std::move(shared));
      });
      Connect(lr_ipc_in_shared_);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References Connect(), lr_ipc_in_shared_, process_line_future_, and ProcessLine().

Stop()

void LrIpcIn::Stop

(

)

{
   try {
      // prevent async handlers from using owner state
      if (lr_ipc_in_shared_) {
         lr_ipc_in_shared_->thread_should_exit_.store(true, std::memory_order_release);
         lr_ipc_in_shared_->owner_alive_->store(false, std::memory_order_release);
 
         if (auto& sock {lr_ipc_in_shared_->socket_}; sock.is_open()) {
            asio::error_code ec;
            /* For portable behaviour with respect to graceful closure of a connected socket, call
             * shutdown() before closing the socket. */
            try { /* ignore exceptions from shutdown, always close */
               std::ignore = sock.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
               if (ec) {
                  rsj::Log(fmt::format("LR_IPC_In socket shutdown error {}.", ec.message()),
                      std::source_location::current());
                  ec.clear();
               }
            }
            catch (const std::exception& e) {
               rsj::Log(fmt::format("Exception during socket shutdown: {}", e.what()),
                   std::source_location::current());
            }
            std::ignore = sock.close(ec);
            if (ec) {
               rsj::Log(fmt::format("LR_IPC_In socket close error {}.", ec.message()),
                   std::source_location::current());
            }
         }
         /* clear input queue after port closed */
         if (const auto m {lr_ipc_in_shared_->line_.clear_count_emplace(kTerminate)}) {
            rsj::Log(fmt::format("{} left in queue in LrIpcIn destructor.", m),
                std::source_location::current());
         }
      }
   }
 
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References lr_ipc_in_shared_.

Member Data Documentation

controls_model_

ControlsModel& LrIpcIn::controls_model_

private

lr_ipc_in_shared_

std::shared_ptr<LrIpcInShared> LrIpcIn::lr_ipc_in_shared_

private

Referenced by Start(), and Stop().

midi_sender_

const MidiSender& LrIpcIn::midi_sender_

private

Referenced by LrIpcIn().

process_line_future_

std::future<void> LrIpcIn::process_line_future_

private

Referenced by Start().

profile_

const Profile& LrIpcIn::profile_

private

Referenced by ProcessLine().

profile_manager_

ProfileManager& LrIpcIn::profile_manager_

private

Referenced by ProcessLine().

---

The documentation for this class was generated from the following files:

• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/LR_IPC_In.h
• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/LR_IPC_In.cpp