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
std::shared_ptr< std::atomic< bool > >	owner_alive_ {std::make_shared<std::atomic<bool>>(true)}
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 owner signalled stop or thread should exit, don't start a new async read
      if (!lr_ipc_shared->owner_alive_->load(std::memory_order_acquire)
          || lr_ipc_shared->thread_should_exit_.load(std::memory_order_acquire)) {
         return;
      }
 
      asio::async_read_until(lr_ipc_shared->socket_, lr_ipc_shared->streambuf_, '\n',
          [lr_ipc_shared, alive = lr_ipc_shared->owner_alive_](const asio::error_code& error,
              const std::size_t bytes_transferred) mutable {
         // if owner signalled Stop(), bail out early
         if (!alive || !alive->load(std::memory_order_acquire)) { return; }
 
         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);
            }
            // before recursively re-arming, make sure owner still alive
            if (alive && alive->load(std::memory_order_acquire)) { Read(std::move(lr_ipc_shared)); }
         }
         else {
            rsj::Log(fmt::format("LR_IPC_In Read error: {}.", error.message()),
                std::source_location::current());
 
            if (error == asio::error::misc_errors::eof) {
               if (auto* app = juce::JUCEApplication::getInstance()) { app->systemRequestedQuit(); }
            }
         }
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Read() [2/2]

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

owner_alive_

std::shared_ptr< std::atomic< bool > > LrIpcInShared::owner_alive_ {std::make_shared<std::atomic<bool>>(true)}

private

{std::make_shared<std::atomic<bool>>(true)};

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