#include <SonicClientPseudoAsync.h>

Inheritance diagram for SonicClientPseudoAsync< InputT, OutputT >:

Public Member Functions
void	dispatch (edm::WaitingTaskWithArenaHolder holder) final

	SonicClientPseudoAsync ()

	~SonicClientPseudoAsync () override

Public Member Functions inherited from SonicClientBase
const std::string &	debugName () const

void	setDebugName (const std::string &debugName)

	SonicClientBase ()

virtual	~SonicClientBase ()=default

Public Member Functions inherited from SonicClientTypes< InputT, OutputT >
Input &	input ()

const Output &	output () const

virtual	~SonicClientTypes ()=default

Private Member Functions
void	waitForNext ()

Private Attributes
std::condition_variable	cond_

bool	hasCall_

std::mutex	mutex_

std::atomic< bool >	stop_

std::unique_ptr< std::thread >	thread_

Additional Inherited Members
Public Types inherited from SonicClientTypes< InputT, OutputT >
typedef InputT	Input

typedef OutputT	Output

Protected Member Functions inherited from SonicClientBase
virtual unsigned	allowedTries () const

virtual void	evaluate ()=0

void	finish (bool success, std::exception_ptr eptr=std::exception_ptr{})

void	setStartTime ()

Protected Attributes inherited from SonicClientBase
std::string	debugName_

edm::WaitingTaskWithArenaHolder	holder_

std::chrono::time_point< std::chrono::high_resolution_clock >	t0_

unsigned	tries_

Protected Attributes inherited from SonicClientTypes< InputT, OutputT >
Input	input_

Output	output_

Detailed Description

template<typename InputT, typename OutputT = InputT>
class SonicClientPseudoAsync< InputT, OutputT >

Definition at line 17 of file SonicClientPseudoAsync.h.

Constructor & Destructor Documentation

◆ SonicClientPseudoAsync()

template<typename InputT , typename OutputT = InputT>

SonicClientPseudoAsync< InputT, OutputT >::SonicClientPseudoAsync ( )

inline

Definition at line 20 of file SonicClientPseudoAsync.h.

                            : SonicClientBase(), SonicClientTypes<InputT, OutputT>(), hasCall_(false), stop_(false) {
     thread_ = std::make_unique<std::thread>([this]() { waitForNext(); });
   }

References SonicClientPseudoAsync< InputT, OutputT >::thread_, and SonicClientPseudoAsync< InputT, OutputT >::waitForNext().

◆ ~SonicClientPseudoAsync()

template<typename InputT , typename OutputT = InputT>

SonicClientPseudoAsync< InputT, OutputT >::~SonicClientPseudoAsync ( )

inlineoverride

Definition at line 24 of file SonicClientPseudoAsync.h.

                                      {
     stop_ = true;
     cond_.notify_one();
     if (thread_) {
       try {
         thread_->join();
         thread_.reset();
       } catch (...) {
       }
     }
   }

References SonicClientPseudoAsync< InputT, OutputT >::cond_, SonicClientPseudoAsync< InputT, OutputT >::stop_, and SonicClientPseudoAsync< InputT, OutputT >::thread_.

Member Function Documentation

◆ dispatch()

template<typename InputT , typename OutputT = InputT>

void SonicClientPseudoAsync< InputT, OutputT >::dispatch ( edm::WaitingTaskWithArenaHolder holder )

inlinefinalvirtual

Implements SonicClientBase.

Definition at line 36 of file SonicClientPseudoAsync.h.

                                                             {
     //do all read/writes inside lock to ensure cache synchronization
     {
       std::lock_guard<std::mutex> guard(mutex_);
       holder_ = std::move(holder);
       setStartTime();
  
       //activate thread to wait for response, and return
       hasCall_ = true;
     }
     cond_.notify_one();
   }

References SonicClientPseudoAsync< InputT, OutputT >::cond_, SonicClientPseudoAsync< InputT, OutputT >::hasCall_, SonicClientBase::holder_, eostools::move(), SonicClientPseudoAsync< InputT, OutputT >::mutex_, and SonicClientBase::setStartTime().

◆ waitForNext()

template<typename InputT , typename OutputT = InputT>

void SonicClientPseudoAsync< InputT, OutputT >::waitForNext ( )

inlineprivate

Definition at line 50 of file SonicClientPseudoAsync.h.

                      {
     while (true) {
       //wait for condition
       {
         std::unique_lock<std::mutex> lk(mutex_);
         cond_.wait(lk, [this]() { return (hasCall_ or stop_); });
         if (stop_)
           break;
  
         //do everything inside lock
         evaluate();
  
         //reset condition
         hasCall_ = false;
       }
     }
   }