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)}
{
}

~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 {
         if (!error) {
            rsj::Log("Socket connected in LR_IPC_In.", std::source_location::current());
            LrIpcInShared::Read(std::move(lr_ipc_shared));
         }
         else {
            rsj::Log(fmt::format(FMT_STRING("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(FMT_STRING("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;
   }
}

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") {
            juce::JUCEApplication::getInstance()->systemRequestedQuit();
            return;
         }
 
         if (value_view.empty()) {
            rsj::Log(fmt::format(FMT_STRING("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(FMT_STRING("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(FMT_STRING("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_13_3)
         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(FMT_STRING("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(FMT_STRING("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;
   }
}

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;
   }
}

Stop()

void LrIpcIn::Stop

(

)

{
   try {
      lr_ipc_in_shared_->thread_should_exit_.store(true, 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(FMT_STRING("LR_IPC_In socket shutdown error {}."),
                            ec.message()),
                   std::source_location::current());
               ec.clear();
            }
         }
         catch (const std::exception& e) {
            rsj::Log(fmt::format(FMT_STRING("Exception during socket shutdown: {}"), e.what()),
                std::source_location::current());
         }
         std::ignore = sock.close(ec);
         if (ec) {
            rsj::Log(fmt::format(FMT_STRING("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(FMT_STRING("{} left in queue in LrIpcIn destructor."), m),
             std::source_location::current());
      }
   }
 
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Member Data Documentation

controls_model_

ControlsModel& LrIpcIn::controls_model_

private

lr_ipc_in_shared_

std::shared_ptr<LrIpcInShared> LrIpcIn::lr_ipc_in_shared_

private

midi_sender_

const MidiSender& LrIpcIn::midi_sender_

private

process_line_future_

std::future<void> LrIpcIn::process_line_future_

private

profile_

const Profile& LrIpcIn::profile_

private

profile_manager_

ProfileManager& LrIpcIn::profile_manager_

private

---

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