LrIpcInShared Class Reference

Public Member Functions
	LrIpcInShared (asio::io_context &io_context)
	LrIpcInShared (asio::io_context &io_context)

Static Private Member Functions
static void	Read (std::shared_ptr< LrIpcInShared > lr_ipc_shared)
static void	Read (std::shared_ptr< LrIpcInShared > lr_ipc_shared)

Private Attributes
rsj::ConcurrentQueue< std::string >	line_
friend	LrIpcIn
asio::ip::tcp::socket	socket_
asio::streambuf	streambuf_ {}
std::atomic< bool >	thread_should_exit_ {false}

Constructor & Destructor Documentation

LrIpcInShared() [1/2]

LrIpcInShared::LrIpcInShared ( asio::io_context &  io_context )

inlineexplicit

: socket_ {asio::make_strand(io_context)} {}

LrIpcInShared() [2/2]

LrIpcInShared::LrIpcInShared ( asio::io_context &  io_context )

inlineexplicit

: socket_ {asio::make_strand(io_context)} {}

Member Function Documentation

Read() [1/2]

void LrIpcInShared::Read ( std::shared_ptr< LrIpcInShared >  lr_ipc_shared )

staticprivate

{
   using namespace std::string_literals;
   try {
      if (!lr_ipc_shared->thread_should_exit_.load(std::memory_order_acquire)) {
         asio::async_read_until(lr_ipc_shared->socket_, lr_ipc_shared->streambuf_, '\n',
             [lr_ipc_shared](const asio::error_code& error,
                 const std::size_t bytes_transferred) mutable {
            if (!error) [[likely]] {
               if (bytes_transferred == 0) [[unlikely]] { std::this_thread::sleep_for(kEmptyWait); }
               else {
                  auto& buf {lr_ipc_shared->streambuf_};
                  std::string command {buffers_begin(buf.data()),
                      buffers_begin(buf.data()) + gsl::narrow<std::ptrdiff_t>(bytes_transferred)};
                  if (command == "TerminateApplication 1\n"s) {
                     lr_ipc_shared->thread_should_exit_.store(true, std::memory_order_release);
                  }
                  lr_ipc_shared->line_.push(std::move(command));
                  buf.consume(bytes_transferred);
               }
               Read(std::move(lr_ipc_shared));
            }
            else {
               rsj::Log(fmt::format(FMT_STRING("LR_IPC_In Read error: {}."), error.message()),
                   std::source_location::current());
 
               if (error == asio::error::misc_errors::eof) { /* LR closed socket */
                  juce::JUCEApplication::getInstance()->systemRequestedQuit();
               }
            }
         });
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Read() [2/2]

static void LrIpcInShared::Read ( std::shared_ptr< LrIpcInShared >  lr_ipc_shared )

staticprivate

Member Data Documentation

line_

rsj::ConcurrentQueue< std::string > LrIpcInShared::line_

private

LrIpcIn

LrIpcIn

private

socket_

asio::ip::tcp::socket LrIpcInShared::socket_

private

streambuf_

asio::streambuf LrIpcInShared::streambuf_ {}

private

{};

thread_should_exit_

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

private

{false};

---

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

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