#include <TRootXTReq.h>

Public Member Functions
void	ShootRequest ()

void	ShootRequestAndWait ()

	TRootXTReq (const char *n="TRootXTReq")

virtual	~TRootXTReq ()

Static Public Member Functions
static void	Bootstrap (pthread_t root_thread)

static void	ProcessQueue ()

static void	Shutdown ()

Protected Member Functions
void	post_request ()

Protected Attributes
TString	mName

Private Types
typedef std::list< TRootXTReq * >	lpXTReq_t

Private Member Functions
virtual void	Act ()=0

Private Attributes
TCondition *	m_return_condition

Static Private Attributes
static lpXTReq_t	sQueue

static TMutex *	sQueueMutex = nullptr

static pthread_t	sRootThread = 0

static bool	sSheduled = false

static TSignalHandler *	sSigHandler = nullptr

Detailed Description

Definition at line 17 of file TRootXTReq.h.

Member Typedef Documentation

typedef std::list<TRootXTReq*> TRootXTReq::lpXTReq_t

private

Definition at line 20 of file TRootXTReq.h.

Constructor & Destructor Documentation

TRootXTReq::TRootXTReq ( const char * n = "TRootXTReq" )

Definition at line 50 of file TRootXTReq.cc.

                                     :
    m_return_condition(nullptr),
    mName(n)
 {}

TRootXTReq::~TRootXTReq ( )

virtual

Definition at line 55 of file TRootXTReq.cc.

References m_return_condition.

 {
    delete m_return_condition;
 }

Member Function Documentation

virtual void TRootXTReq::Act ( )

privatepure virtual

Referenced by ProcessQueue().

void TRootXTReq::Bootstrap ( pthread_t root_thread )

static

Definition at line 151 of file TRootXTReq.cc.

References sQueueMutex, sRootThread, and sSigHandler.

 {
    static const TString _eh("TRootXTReq::Bootstrap ");
 
    if (sRootThread != 0)
       throw _eh + "Already initialized.";
 
    sRootThread = root_thread;
    sQueueMutex = new TMutex(kTRUE);
    sSigHandler = new RootSig2XTReqHandler;
 }

void TRootXTReq::post_request ( )

protected

Definition at line 62 of file TRootXTReq.cc.

References sQueue, sQueueMutex, sRootThread, and sSheduled.

Referenced by ShootRequest(), and ShootRequestAndWait().

 {
    TLockGuard _lck(sQueueMutex);
 
    sQueue.push_back(this);
 
    if ( ! sSheduled)
    {
       sSheduled = true;
       pthread_kill(sRootThread, SIGUSR1);
    }
 }

void TRootXTReq::ProcessQueue ( )

static

Definition at line 177 of file TRootXTReq.cc.

References Act(), m_return_condition, sQueue, sQueueMutex, and sSheduled.

Referenced by RootSig2XTReqHandler::XTReqTimer::Notify().

 {
    printf("Timer fired, processing queue.\n");
 
    while (true)
    {
       TRootXTReq *req = nullptr;
       {
          TLockGuard _lck(sQueueMutex);
 
          if ( ! sQueue.empty())
          {
             req = sQueue.front();
             sQueue.pop_front();
          }
          else
          {
             sSheduled = false;
             break;
          }
       }
 
       req->Act();
 
       if (req->m_return_condition)
       {
          req->m_return_condition->GetMutex()->Lock();
          req->m_return_condition->Signal();
          req->m_return_condition->GetMutex()->UnLock();
       }
       else
       {
          delete req;
       }
    }
 }

void TRootXTReq::ShootRequest ( )

Definition at line 75 of file TRootXTReq.cc.

References m_return_condition, and post_request().

 {
    // Places request into the queue and requests execution in Rint thread.
    // It returns immediately after that, without waiting for execution.
    // The request is deleted after execution.
 
    if (m_return_condition)
    {
       delete m_return_condition;
       m_return_condition = nullptr;
    }
 
    post_request();
 }

void TRootXTReq::ShootRequestAndWait ( )

Definition at line 90 of file TRootXTReq.cc.

References m_return_condition, and post_request().

 {
    // Places request into the queue, requests execution in Rint thread and
    // waits for the execution to be completed.
    // The request is not deleted after execution as it might carry return
    // value.
    // The same request can be reused several times.
 
    if (!m_return_condition)
       m_return_condition = new TCondition;
 
    m_return_condition->GetMutex()->Lock();
 
    post_request();
 
    m_return_condition->Wait();
    m_return_condition->GetMutex()->UnLock();
 }

void TRootXTReq::Shutdown ( )

static

Definition at line 163 of file TRootXTReq.cc.

References sQueueMutex, sRootThread, and sSigHandler.

 {
    static const TString _eh("TRootXTReq::Shutdown ");
 
    if (sRootThread == 0)
       throw _eh + "Have not beem initialized.";
 
    // Should lock and drain queue ... or sth.
 
    sRootThread = 0;
    delete sSigHandler; sSigHandler = nullptr;
    delete sQueueMutex; sQueueMutex = nullptr;
 }