TRootXTReq Class Reference

#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

lpXTReq_t

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

private

Definition at line 19 of file TRootXTReq.h.

Constructor & Destructor Documentation

TRootXTReq()

TRootXTReq::TRootXTReq

(

const char *

n = "TRootXTReq"

)

Definition at line 48 of file TRootXTReq.cc.

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

~TRootXTReq()

TRootXTReq::~TRootXTReq ( )

virtual

Definition at line 50 of file TRootXTReq.cc.

{ delete m_return_condition; }

References m_return_condition.

Member Function Documentation

Act()

virtual void TRootXTReq::Act ( )

privatepure virtual

Referenced by ProcessQueue().

Bootstrap()

void TRootXTReq::Bootstrap ( pthread_t  root_thread )

static

Definition at line 132 of file TRootXTReq.cc.

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

References sQueueMutex, sRootThread, and sSigHandler.

post_request()

void TRootXTReq::post_request ( )

protected

Definition at line 54 of file TRootXTReq.cc.

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

References sQueue, sQueueMutex, sRootThread, and sSheduled.

Referenced by ShootRequest(), and ShootRequestAndWait().

ProcessQueue()

void TRootXTReq::ProcessQueue ( )

static

Definition at line 158 of file TRootXTReq.cc.

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

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

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

ShootRequest()

void TRootXTReq::ShootRequest

(

)

Definition at line 65 of file TRootXTReq.cc.

                              {
  // 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();
}

References m_return_condition, and post_request().

ShootRequestAndWait()

void TRootXTReq::ShootRequestAndWait

(

)

Definition at line 78 of file TRootXTReq.cc.

                                     {
  // 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();
}

References m_return_condition, and post_request().

Shutdown()

void TRootXTReq::Shutdown ( )

static

Definition at line 143 of file TRootXTReq.cc.

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

References sQueueMutex, sRootThread, and sSigHandler.

Member Data Documentation

m_return_condition

TCondition* TRootXTReq::m_return_condition

private

Definition at line 21 of file TRootXTReq.h.

Referenced by ProcessQueue(), ShootRequest(), ShootRequestAndWait(), and ~TRootXTReq().

mName

TString TRootXTReq::mName

protected

Definition at line 32 of file TRootXTReq.h.

sQueue

TRootXTReq::lpXTReq_t TRootXTReq::sQueue

staticprivate

Definition at line 23 of file TRootXTReq.h.

Referenced by post_request(), and ProcessQueue().

sQueueMutex

TMutex * TRootXTReq::sQueueMutex = nullptr

staticprivate

Definition at line 25 of file TRootXTReq.h.

Referenced by Bootstrap(), post_request(), ProcessQueue(), and Shutdown().

sRootThread

pthread_t TRootXTReq::sRootThread = 0

staticprivate

Definition at line 24 of file TRootXTReq.h.

Referenced by Bootstrap(), post_request(), and Shutdown().

sSheduled

bool TRootXTReq::sSheduled = false

staticprivate

Definition at line 27 of file TRootXTReq.h.

Referenced by post_request(), and ProcessQueue().

sSigHandler

TSignalHandler * TRootXTReq::sSigHandler = nullptr

staticprivate

Definition at line 26 of file TRootXTReq.h.

Referenced by Bootstrap(), and Shutdown().