LrIpcOut Class Reference

#include <LR_IPC_Out.h>

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	RepeatCmdIterator = const std::unordered_map< std::string, std::pair< std::string, std::string > >::const_iterator

Private Member Functions
void	Connect (std::shared_ptr< LrIpcOutShared > lr_ipc_out_shared)
void	ConnectionMade ()
void	MidiCmdCallback (rsj::MidiMessage mm)
void	ProcessChange (const RepeatCmdIterator &repeats, const rsj::MidiMessage &mm) const
void	ProcessMessage (const rsj::MidiMessageId &message, const rsj::MidiMessage &mm)
void	ProcessNonRepeatedCommand (const std::string &command_to_send, const rsj::MidiMessage &mm) const
void	ProcessRepeatedCommand (const RepeatCmdIterator &repeats, const rsj::MidiMessage &mm, const rsj::MidiMessageId &message)
void	SetRecenter (rsj::MidiMessageId mm)
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_
asio::steady_timer	recenter_timer_
const std::unordered_map< std::string, std::pair< std::string, std::string > > &	repeat_cmd_
bool	sending_stopped_ {false}
std::atomic< bool >	thread_should_exit_ {false}
const std::vector< std::string > &	wrap_

Member Typedef Documentation

RepeatCmdIterator

using LrIpcOut::RepeatCmdIterator = const std::unordered_map<std::string, std::pair<std::string, std::string> >::const_iterator

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
	)

    : recenter_timer_ {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);
}

~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::*)(bool, bool)  mf  )

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 {
         if (!error) {
            ConnectionMade();
            LrIpcOutShared::SendOut(std::move(lr_ipc_out_shared));
         }
         else {
            rsj::Log(fmt::format(FMT_STRING("LR_IPC_Out did not connect. {}."), error.message()));
            asio::error_code ec2;
            std::ignore = lr_ipc_out_shared->socket_.close(ec2);
            if (ec2) {
               rsj::Log(fmt::format(FMT_STRING("LR_IPC_Out socket close error {}."),
                   ec2.message()));
            }
         }
          });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

ConnectionMade()

void LrIpcOut::ConnectionMade ( )

private

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

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

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

ProcessChange()

void LrIpcOut::ProcessChange ( 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 */
   }
}

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()) {
         ProcessNonRepeatedCommand(command_to_send, mm);
      }
      else {
         ProcessRepeatedCommand(repeats, mm, message);
      }
   }
}

ProcessNonRepeatedCommand()

void LrIpcOut::ProcessNonRepeatedCommand ( 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(FMT_STRING("{} {}\n"), command_to_send, computed_value));
}

ProcessRepeatedCommand()

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

private

{
   static TimePoint next_response {};
   if (const auto now {Clock::now()}; next_response < now) {
      next_response = now + kDelay;
      if (ShouldSetRecenter(mm)) { SetRecenter(message); }
      ProcessChange(repeats, mm);
   }
}

SendCommand() [1/2]

void LrIpcOut::SendCommand

(

const std::string &

command

)

const

{
   if (!sending_stopped_) { lr_ipc_out_shared_->command_.push(command); }
}

SendCommand() [2/2]

void LrIpcOut::SendCommand

(

std::string &&

command

)

const

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

SendingRestart()

void LrIpcOut::SendingRestart

(

)

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

SendingStop()

void LrIpcOut::SendingStop

(

)

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

SetRecenter()

void LrIpcOut::SetRecenter ( rsj::MidiMessageId  mm )

private

{
   /* by capturing mm by copy, don't have to worry about later calls changing it--those will just
    * cancel and reschedule new one */
   try {
      recenter_timer_.expires_after(kRecenterTimer);
      recenter_timer_.async_wait([this, mm](const asio::error_code& error) {
         if (!error && !thread_should_exit_.load(std::memory_order_acquire)) {
            midi_sender_.Send(mm, controls_model_.SetToCenter(mm));
         }
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

ShouldSetRecenter()

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

private

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

Start()

void LrIpcOut::Start ( )

inline

{ Connect(lr_ipc_out_shared_); }

Stop()

void LrIpcOut::Stop

(

)

{
   thread_should_exit_.store(true, 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(FMT_STRING("{} left in queue in LrIpcOut destructor."), m));
   }
   {
      std::scoped_lock lk(callback_mtx_);
      callbacks_.clear(); /* no more connect/disconnect notifications */
   }
   recenter_timer_.cancel();
   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(FMT_STRING("LR_IPC_Out 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_Out socket close error {}."), ec.message()));
      }
   }
}

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

controls_model_

ControlsModel& LrIpcOut::controls_model_

private

lr_ipc_out_shared_

std::shared_ptr<LrIpcOutShared> LrIpcOut::lr_ipc_out_shared_

private

midi_sender_

const MidiSender& LrIpcOut::midi_sender_

private

profile_

const Profile& LrIpcOut::profile_

private

recenter_timer_

asio::steady_timer LrIpcOut::recenter_timer_

private

repeat_cmd_

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

private

sending_stopped_

bool LrIpcOut::sending_stopped_ {false}

private

{false};

thread_should_exit_

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

private

{false};

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