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.");
            LrIpcInShared::Read(std::move(lr_ipc_shared));
         }
         else {
            rsj::Log(fmt::format(FMT_STRING("LR_IPC_In did not connect. {}."), error.message()));
            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()));
            }
         }
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      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 {
      for (auto line_copy = lr_ipc_shared->line_.pop(); line_copy != kTerminate;
           line_copy = lr_ipc_shared->line_.pop()) {
         auto [command_view, value_view] {SplitLine(line_copy)};
         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)));
         }
         else if (command_view == "SwitchProfile") {
            profile_manager_.SwitchToProfile(std::string(value_view));
         }
         else if (command_view == "Log") {
            rsj::Log(fmt::format(FMT_STRING("Plugin: {}."), value_view));
         }
         else if (command_view == "SendKey") {
            int modifiers = 0;
            std::from_chars(value_view.data(), value_view.data() + value_view.size(), modifiers);
            /* trim twice on purpose: first modifiers digits, then one space (fixed delimiter) */
            const auto first_not_digit {value_view.find_first_not_of("0123456789")};
            if (first_not_digit != std::string_view::npos) {
               value_view.remove_prefix(first_not_digit + 1);
               if (!value_view.empty()) {
                  rsj::SendKeyDownUp(std::string(value_view),
                      rsj::ActiveModifiers::FromMidi2LR(modifiers));
                  continue; /* skip log and alert error */
               }
            }
            rsj::LogAndAlertError(fmt::format(FMT_STRING("SendKey couldn't identify keystroke. "
                                                         "Message from plugin was \"{}\"."),
                rsj::ReplaceInvisibleChars(line_copy)));
         }
         else { /* send associated messages to MIDI OUT devices */
#ifdef _MSC_VER
            double original_value = 0.0;
            std::from_chars(value_view.data(), value_view.data() + value_view.size(),
                original_value);
#else  //Xcode doesn't support double from_chars yet (15.2)
            const auto original_value {std::stod(std::string(value_view))};
#endif
            const auto messages {profile_.GetMessagesForCommand(std::string(command_view))};
            for (const auto& msg : messages) {
               /* following needs to run for all controls: sets saved value */
               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);
      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);
      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()));
               ec.clear();
            }
         }
         catch (const std::exception& e) {
            rsj::Log(fmt::format(FMT_STRING("Exception during socket shutdown: {}"), e.what()));
         }
         std::ignore = sock.close(ec);
         if (ec) {
            rsj::Log(fmt::format(FMT_STRING("LR_IPC_In socket close error {}."), ec.message()));
         }
      }
      /* 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));
      }
   }
 
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      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