LrIpcOut Class Reference

#include <LR_IPC_Out.h>

Classes
struct	RecenterInfo

Public Member Functions
	LrIpcOut (const CommandSet &command_set, ControlsModel &c_model, const Profile &profile, const MidiSender &midi_sender, MidiReceiver &midi_receiver, asio::io_context &io_context)
	LrIpcOut (const LrIpcOut &other)=delete
	LrIpcOut (LrIpcOut &&other)=delete
	~LrIpcOut ()=default
template<class T>
void	AddCallback (_In_ T *const object, _In_ void(T::*const mf)(bool, bool))
LrIpcOut &	operator= (const LrIpcOut &other)=delete
LrIpcOut &	operator= (LrIpcOut &&other)=delete
void	SendCommand (const std::string &command) const
void	SendCommand (std::string &&command) const
void	SendingRestart ()
void	SendingStop ()
void	Start ()
void	Stop ()

Private Types
using	Clock = std::chrono::steady_clock
using	RepeatCmdIterator
using	TimePoint = Clock::time_point

Private Member Functions
void	Connect (std::shared_ptr< LrIpcOutShared > lr_ipc_out_shared)
void	ConnectionMade ()
void	MidiCmdCallback (rsj::MidiMessage mm)
void	ProcessMessage (const rsj::MidiMessageId &message, const rsj::MidiMessage &mm)
void	ProcessRepeatedCommand (const RepeatCmdIterator &repeats, const rsj::MidiMessage &mm, const rsj::MidiMessageId &message)
void	SendNonRepeatedCommand (const std::string &command_to_send, const rsj::MidiMessage &mm) const
void	SendRepeatedCommand (const RepeatCmdIterator &repeats, const rsj::MidiMessage &mm) const
void	SetRecenter (const rsj::MidiMessageId &, RecenterInfo &)
bool	ShouldSetRecenter (const rsj::MidiMessage &mm) const

Private Attributes
std::mutex	callback_mtx_
std::vector< std::function< void(bool, bool)> >	callbacks_ {}
bool	connected_ {false}
ControlsModel &	controls_model_
std::shared_ptr< LrIpcOutShared >	lr_ipc_out_shared_
const MidiSender &	midi_sender_
const Profile &	profile_
std::map< rsj::MidiMessageId, RecenterInfo >	recenter_timers_
std::mutex	recenter_timers_mtx_ {}
const std::unordered_map< std::string, std::pair< std::string, std::string > > &	repeat_cmd_
std::atomic< bool >	sending_stopped_ {false}
asio::strand< asio::io_context::executor_type >	timer_strand_
const std::vector< std::string > &	wrap_

Member Typedef Documentation

Clock

using LrIpcOut::Clock = std::chrono::steady_clock

private

RepeatCmdIterator

using LrIpcOut::RepeatCmdIterator

private

Initial value:

 
const std::unordered_map<std::string, std::pair<std::string, std::string>>::const_iterator

TimePoint

using LrIpcOut::TimePoint = Clock::time_point

private

Constructor & Destructor Documentation

LrIpcOut() [1/3]

LrIpcOut::LrIpcOut	(	const CommandSet &	command_set,
		ControlsModel &	c_model,
		const Profile &	profile,
		const MidiSender &	midi_sender,
		MidiReceiver &	midi_receiver,
		asio::io_context &	io_context )

    : timer_strand_ {asio::make_strand(io_context)}, midi_sender_ {midi_sender}, profile_ {profile},
      repeat_cmd_ {command_set.GetRepeats()}, wrap_ {command_set.GetWraps()},
      controls_model_ {c_model}, lr_ipc_out_shared_ {std::make_shared<LrIpcOutShared>(io_context)}
{
   midi_receiver.AddCallback(this, &LrIpcOut::MidiCmdCallback);
}

References timer_strand_.

~LrIpcOut()

LrIpcOut::~LrIpcOut ( )

default

LrIpcOut() [2/3]

LrIpcOut::LrIpcOut ( const LrIpcOut & other )

delete

LrIpcOut() [3/3]

LrIpcOut::LrIpcOut ( LrIpcOut && other )

delete

Member Function Documentation

AddCallback()

template<class T>

void LrIpcOut::AddCallback ( _In_ T *const object, _In_ void(T::* mf )(bool, bool) )

inline

   {
      if (object && mf) {
         std::scoped_lock lk(callback_mtx_);
         callbacks_.emplace_back(std::bind_front(mf, object));
      }
   }

Connect()

void LrIpcOut::Connect ( std::shared_ptr< LrIpcOutShared > lr_ipc_out_shared )

private

{
   try {
      lr_ipc_out_shared->socket_.async_connect(
          asio::ip::tcp::endpoint(asio::ip::address_v4::loopback(), kLrOutPort),
          [this, lr_ipc_out_shared](const asio::error_code& error) mutable {
         // copy shared alive token so the handler can detect owner shutdown
         auto alive {lr_ipc_out_shared->owner_alive_};
         if (!alive || !alive->load(std::memory_order_acquire)) { return; }
         if (!error) {
            // check again just before calling member functions
            if (alive->load(std::memory_order_acquire)) { ConnectionMade(); }
            LrIpcOutShared::SendOut(std::move(lr_ipc_out_shared));
         }
         else {
            rsj::Log(fmt::format("LR_IPC_Out did not connect. {}.", error.message()),
                std::source_location::current());
            asio::error_code ec2;
            std::ignore = lr_ipc_out_shared->socket_.close(ec2);
            if (ec2) {
               rsj::Log(fmt::format("LR_IPC_Out 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().

ConnectionMade()

void LrIpcOut::ConnectionMade ( )

private

{
   try {
      {
         std::scoped_lock lk(callback_mtx_);
         connected_ = true;
         auto stopped {sending_stopped_.load(std::memory_order_acquire)};
         for (const auto& cb : callbacks_) { cb(true, stopped); }
      }
      rsj::Log("Socket connected in LR_IPC_Out.", std::source_location::current());
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References connected_, and sending_stopped_.

MidiCmdCallback()

void LrIpcOut::MidiCmdCallback ( rsj::MidiMessage mm )

private

{
   try {
      const rsj::MidiMessageId message {mm};
      if (profile_.MessageExistsInMap(message)) { ProcessMessage(message, mm); }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References rsj::MidiMessageId::MidiMessageId(), Profile::MessageExistsInMap(), ProcessMessage(), and profile_.

operator=() [1/2]

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

delete

operator=() [2/2]

LrIpcOut & LrIpcOut::operator= ( LrIpcOut && other )

delete

ProcessMessage()

void LrIpcOut::ProcessMessage ( const rsj::MidiMessageId & message, const rsj::MidiMessage & mm )

private

{
   const auto command_to_send {profile_.GetCommandForMessage(message)};
   if (rollbear::none_of("PrevPro", "NextPro", CommandSet::kUnassigned) == command_to_send) {
      if (const auto repeats {repeat_cmd_.find(command_to_send)}; repeats == repeat_cmd_.end()) {
         SendNonRepeatedCommand(command_to_send, mm);
      }
      else {
         ProcessRepeatedCommand(repeats, mm, message);
      }
   }
}

References Profile::GetCommandForMessage(), profile_, repeat_cmd_, and SendNonRepeatedCommand().

Referenced by MidiCmdCallback().

ProcessRepeatedCommand()

void LrIpcOut::ProcessRepeatedCommand ( const RepeatCmdIterator & repeats, const rsj::MidiMessage & mm, const rsj::MidiMessageId & message )

private

{
   auto lock {std::unique_lock(recenter_timers_mtx_)}; // Always lock first keep iterator stable
   auto [it, _] {recenter_timers_.try_emplace(message, timer_strand_)};
   if (const auto now {Clock::now()}; it->second.timepoint < now) {
      it->second.timepoint = now + kDelay;
      if (ShouldSetRecenter(mm)) { SetRecenter(message, it->second); }
      lock.unlock(); // Unlock before sending command
      SendRepeatedCommand(repeats, mm);
   }
}

References recenter_timers_, SetRecenter(), ShouldSetRecenter(), and timer_strand_.

SendCommand() [1/2]

void LrIpcOut::SendCommand

(

const std::string &

command

)

const

{
   if (!sending_stopped_.load(std::memory_order_acquire)) {
      lr_ipc_out_shared_->command_.push(command);
   }
}

References sending_stopped_.

SendCommand() [2/2]

void LrIpcOut::SendCommand

(

std::string &&

command

)

const

{
   if (!sending_stopped_.load(std::memory_order_acquire)) {
      lr_ipc_out_shared_->command_.push(std::move(command));
   }
}

References sending_stopped_.

Referenced by SettingsManager::ConnectionCallback(), SendingRestart(), SettingsManager::SetPickupEnabled(), and SettingsManager::WriteDebugInfo().

SendingRestart()

void LrIpcOut::SendingRestart

(

)

{
   try {
      {
         std::scoped_lock lk(callback_mtx_);
         sending_stopped_.store(false, std::memory_order_release);
         for (const auto& cb : callbacks_) { cb(connected_, false); }
      }
      SendCommand("FullRefresh 1\n"); /* synchronize controls */
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References SendCommand(), and sending_stopped_.

Referenced by MainContentComponent::DisconnectClicked().

SendingStop()

void LrIpcOut::SendingStop

(

)

{
   try {
      std::scoped_lock lk(callback_mtx_);
      sending_stopped_.store(true, std::memory_order_release);
      for (const auto& cb : callbacks_) { cb(connected_, true); }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References sending_stopped_.

Referenced by MainContentComponent::DisconnectClicked().

SendNonRepeatedCommand()

void LrIpcOut::SendNonRepeatedCommand ( const std::string & command_to_send, const rsj::MidiMessage & mm ) const

private

{
#ifdef __cpp_lib_ranges_contains
   const auto wrap {std::ranges::contains(wrap_, command_to_send)};
#else
   const auto wrap {std::ranges::find(wrap_, command_to_send) != wrap_.end()};
#endif
   const auto computed_value {controls_model_.ControllerToPlugin(mm, wrap)};
   SendCommand(fmt::format("{} {}\n", command_to_send, computed_value));
}

References ControlsModel::ControllerToPlugin(), and controls_model_.

Referenced by ProcessMessage().

SendRepeatedCommand()

void LrIpcOut::SendRepeatedCommand ( const RepeatCmdIterator & repeats, const rsj::MidiMessage & mm ) const

private

{
   if (const auto change {controls_model_.MeasureChange(mm)}; change > 0) {
      SendCommand(repeats->second.first); /* turned clockwise */
   }
   else if (change < 0) {
      SendCommand(repeats->second.second); /* turned counterclockwise */
   }
}

References controls_model_, and ControlsModel::MeasureChange().

SetRecenter()

void LrIpcOut::SetRecenter ( const rsj::MidiMessageId & mm, RecenterInfo & info )

private

{
   try {
      info.timer.expires_after(kRecenterTimer);
      info.timer.async_wait(
          [this, mm, alive = lr_ipc_out_shared_->owner_alive_](const asio::error_code& error) {
         if (error) { return; } // Handle cancellation/errors
         if (!alive || !alive->load(std::memory_order_acquire)) { return; }
         midi_sender_.Send(mm, controls_model_.SetToCenter(mm));
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References LrIpcOut::RecenterInfo::timer.

Referenced by ProcessRepeatedCommand().

ShouldSetRecenter()

bool LrIpcOut::ShouldSetRecenter ( const rsj::MidiMessage & mm ) const

nodiscardprivate

{
   return (mm.message_type_byte == rsj::MessageType::kCc
              && controls_model_.GetCcMethod(mm.channel, mm.control_number)
                     == rsj::CCmethod::kAbsolute)
          || mm.message_type_byte == rsj::MessageType::kPw;
}

References rsj::MidiMessage::channel, rsj::MidiMessage::control_number, controls_model_, ControlsModel::GetCcMethod(), rsj::kAbsolute, rsj::kCc, rsj::kPw, and rsj::MidiMessage::message_type_byte.

Referenced by ProcessRepeatedCommand().

Start()

void LrIpcOut::Start ( )

inline

{ Connect(lr_ipc_out_shared_); }

References Connect(), and lr_ipc_out_shared_.

Stop()

void LrIpcOut::Stop

(

)

{
   lr_ipc_out_shared_->owner_alive_->store(false, std::memory_order_release);
   /* clear output queue before port closed */
   if (const auto m {lr_ipc_out_shared_->command_.clear_count_emplace(kTerminate)}) {
      rsj::Log(fmt::format("{} left in queue in LrIpcOut destructor.", m),
          std::source_location::current());
   }
   {
      std::scoped_lock lk(callback_mtx_);
      callbacks_.clear(); /* no more connect/disconnect notifications */
   }
   {
      std::scoped_lock lk2(recenter_timers_mtx_);
      for (auto& [_, centerinfo] : recenter_timers_) {
         asio::error_code ec;
         centerinfo.timer.cancel(ec);
         if (ec) {
            rsj::Log(fmt::format("Error cancelling recenter timer: {}.", ec.message()),
                std::source_location::current());
         }
      }
   }
   if (auto& sock {lr_ipc_out_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_Out 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_Out socket close error {}.", ec.message()),
             std::source_location::current());
      }
   }
}

Member Data Documentation

callback_mtx_

std::mutex LrIpcOut::callback_mtx_

mutableprivate

callbacks_

std::vector<std::function<void(bool, bool)> > LrIpcOut::callbacks_ {}

private

{};

connected_

bool LrIpcOut::connected_ {false}

private

{false};

Referenced by ConnectionMade().

controls_model_

ControlsModel& LrIpcOut::controls_model_

private

Referenced by SendNonRepeatedCommand(), SendRepeatedCommand(), and ShouldSetRecenter().

lr_ipc_out_shared_

std::shared_ptr<LrIpcOutShared> LrIpcOut::lr_ipc_out_shared_

private

Referenced by Start().

midi_sender_

const MidiSender& LrIpcOut::midi_sender_

private

profile_

const Profile& LrIpcOut::profile_

private

Referenced by MidiCmdCallback(), and ProcessMessage().

recenter_timers_

std::map<rsj::MidiMessageId, RecenterInfo> LrIpcOut::recenter_timers_

private

Referenced by ProcessRepeatedCommand().

recenter_timers_mtx_

std::mutex LrIpcOut::recenter_timers_mtx_ {}

private

{};

repeat_cmd_

const std::unordered_map<std::string, std::pair<std::string, std::string> >& LrIpcOut::repeat_cmd_

private

Referenced by ProcessMessage().

sending_stopped_

std::atomic<bool> LrIpcOut::sending_stopped_ {false}

private

{false};

Referenced by ConnectionMade(), SendCommand(), SendCommand(), SendingRestart(), and SendingStop().

timer_strand_

asio::strand<asio::io_context::executor_type> LrIpcOut::timer_strand_

private

Referenced by LrIpcOut(), and ProcessRepeatedCommand().

wrap_

const std::vector<std::string>& LrIpcOut::wrap_

private

---

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

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