---

CTBsignalBase.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <assert.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"

#include "CTBsignalBase.hxx"

//------------------------------------------+-----------------------------------

CTBsignalEmitter::~CTBsignalEmitter()
{
  CTB_Trace("~CTBsignalEmitter()");

  while(m_ehead) {
    CTBsignalLink*         p_link = m_ehead.First();    
    CTBsignalReceiverBase* p_receiver = p_link->m_rlink.Parent();

    p_link->UnlinkEmitter();                // unlink from emitter queue

    if (p_receiver) {                       // receiver still connected 
      if (p_receiver->Blocked()) {          // if blocked, queue it
        p_link->mi_pendingmask = 0;
        if (!p_link->Pending()) {
          p_link->m_plink.InsertTail(p_link, &CTBsignalLink::m_plink,
                                     p_receiver->m_phead);
        }

      } else {                              // if not blocked, deliver
        p_link->Mark();
        try {
          p_receiver->Execute(p_link->mp_emitter,0); // DO IT !!
        } catch(...) {                      // simply drop exception 
        }
        p_link->Unmark();
      }
    }

    if (!p_link->Busy() && !p_link->Pending()) delete p_link; // burry zombie
  }
}

//------------------------------------------+-----------------------------------

int CTBsignalEmitter::NConnect() const
{
  CTB_Trace("CTBsignalEmitter::NConnect()");

  int i_nconnect = 0;
  
  for(CTBsignalLink* p_link = m_ehead.First(); p_link;
                     p_link = p_link->m_elink.Next()) {
    if (!p_link->Zombie()) i_nconnect++;
  }
  
  return i_nconnect;
}

//------------------------------------------+-----------------------------------

void CTBsignalEmitter::Execute(CTBuint32 i_mask) const
{
  CTB_Trace("CTBsignalEmitter::Execute(CTBuint32)");

  if (i_mask == 0) return;                  // drop empty requests

  for(CTBsignalLink* p_link = m_ehead.First(); p_link; ) {
    CTBsignalLink*         p_next = p_link->m_elink.Next();
    CTBsignalReceiverBase* p_receiver = p_link->m_rlink.Parent();

    if (i_mask & p_link->mi_acceptmask) {   // any interest ?

      if (p_receiver) {                     // if still connected
        if (p_receiver->Blocked()) {        // if blocked, queue it
          if (p_link->Pending()) {          // already pending signals ?
            assert(p_link->mi_pendingmask != 0); // !?! connect&pend-> !0 mask
            p_link->mi_pendingmask |= i_mask;
          } else {
            assert(p_link->mi_pendingmask == 0); // !?! !pending -> 0 mask
            p_link->mi_pendingmask = i_mask;
            p_link->m_plink.InsertTail(p_link, &CTBsignalLink::m_plink,
                                       p_receiver->m_phead);
          }
          
        } else {                            // if not blocked, deliver  
          p_link->Mark();                   // lock link against deletion
          try {
            p_receiver->Execute(p_link->mp_emitter,i_mask); // DO IT !!
            
          } catch(...) {                    // simply drop exception
          }
          p_link->Unmark();                 // unlock
        }
        
        p_next = p_link->m_elink.Next();    // re-evaluate in case of deletions
        if (p_link->Deletable()) delete p_link; // burry zombie if possible
      }
    }
    
    p_link = p_next;
  }

  return;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//------------------------------------------+-----------------------------------

CTBsignalReceiverBase::~CTBsignalReceiverBase()
{
  CTB_Trace("~CTBsignalReceiverBase()");

  Disconnect();
}

//------------------------------------------+-----------------------------------

int CTBsignalReceiverBase::NConnect() const
{
  CTB_Trace("CTBsignalReceiverBase::NConnect()");

  int i_nconnect = 0;
  
  for(CTBsignalLink* p_link = m_rhead.First(); p_link;
                     p_link = p_link->m_rlink.Next()) {
    if (!p_link->Zombie()) i_nconnect++;
  }
  
  return i_nconnect;
}

//------------------------------------------+-----------------------------------

void CTBsignalReceiverBase::Disconnect()
{
  CTB_Trace("CTBsignalReceiverBase::Disconnect()");

  while (m_rhead) {
    CTBsignalLink* p_link = m_rhead.First();
    
    if (p_link->Busy()) {
      p_link->UnlinkReceiver();
    } else {
      delete p_link;
    }
  }
  
  return;
}

//------------------------------------------+-----------------------------------

void CTBsignalReceiverBase::Disconnect(CTBsignalEmitter& emitter)
{
  CTB_Trace("CTBsignalReceiverBase::Disconnect(CTBsignalEmitter&)");

  for (CTBsignalLink* p_link = m_rhead.First(); p_link; ) {
    CTBsignalLink* p_next = p_link->m_rlink.Next();

    if (p_link->m_elink.Head() == &emitter.m_ehead) {
      if (p_link->Busy()) {
        p_link->UnlinkReceiver();
      } else {
        delete p_link;
      }
    }
    p_link = p_next;
  }
  
  return;
}

// Notes:
//  1. p_next must be evaluated before the Link object is deleted !!

//------------------------------------------+-----------------------------------

void CTBsignalReceiverBase::Deliver()
{
  CTB_Trace("CTBsignalReceiverBase::Deliver()");

  while (m_phead) {
    CTBsignalLink* p_link = m_phead.First();

    p_link->m_plink.Remove(&CTBsignalLink::m_plink);
    
    try {
      CTBuint32 i_mask=p_link->mi_pendingmask;

      p_link->mi_pendingmask = 0;           // reset mask of delivered signals
      Execute(p_link->mp_emitter, i_mask);
      
    } catch(...) {                          // simply drop exception
    }

  }

  return;
}

// Notes:
//  1. One has to first save the pending signal mask, than clear it, and finally
//     call Execute() because the signal handler can reemit this signal, with
//     the same or potentially a different mask. The algorithm guarantees that
//     each signal mask bit is delivered at least once.

//------------------------------------------+-----------------------------------

CTBsignalReceiverBase& CTBsignalReceiverBase::operator=(
    const CTBsignalReceiverBase& rhs)
{
  CTB_Trace("CTBsignalReceiverBase::operator=(const CTBsignalReceiverBase&)");

  if (this == &rhs) return *this;
  
  Disconnect();
 
  mi_nblock = rhs.mi_nblock;

  for (CTBsignalLink* p_link = rhs.m_rhead.First(); p_link;
       p_link = p_link->m_rlink.Next()) {
    if (!p_link->Zombie()) {
      new CTBsignalLink(*p_link, *this);
    }
  }
  
  return *this;
}

//------------------------------------------+-----------------------------------

void CTBsignalReceiverBase::Connect(CTBsignalEmitter& emitter,
                                    void* p_emitter, CTBuint32 i_mask)
{
  CTB_Trace("CTBsignalReceiverBase::Connect(CTBsignalEmitter&, void*, CTBuint32)");

  new CTBsignalLink(emitter, *this, p_emitter, i_mask);
  return;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifdef DEV_DOCS

#endif

//------------------------------------------+-----------------------------------

CTBsignalLink::CTBsignalLink(CTBsignalEmitter& emitter,
                             CTBsignalReceiverBase& receiver,
                             void* p_emitter, CTBuint32 i_mask)
  : m_elink(),
    m_rlink(),
    m_plink(),
    mi_nbusy(0),
    mp_emitter(p_emitter),
    mi_acceptmask(i_mask),
    mi_pendingmask(0)
{
  CTB_Trace("CTBsignalLink(CTBsignalEmitter&, CTBsignalReceiverBase&, void*, CTBuint32)");

  m_elink.InsertTail(this, &CTBsignalLink::m_elink, emitter.m_ehead);
  m_rlink.InsertTail(this, &CTBsignalLink::m_rlink, 
                     receiver, &CTBsignalReceiverBase::m_rhead);
}

//------------------------------------------+-----------------------------------

CTBsignalLink::CTBsignalLink(const CTBsignalLink& rhs,
                             CTBsignalReceiverBase& receiver)
  : m_elink(),
    m_rlink(),
    m_plink(),
    mi_nbusy(0),
    mp_emitter(rhs.mp_emitter),
    mi_acceptmask(rhs.mi_acceptmask),
    mi_pendingmask(rhs.mi_pendingmask)
{
  CTB_Trace("CTBsignalLink(const CTBsignalLink&, CTBsignalReceiverBase&)");

  m_elink.InsertTail(this, &CTBsignalLink::m_elink, *rhs.m_elink.Head());
  m_rlink.InsertTail(this, &CTBsignalLink::m_rlink, 
                     receiver, &CTBsignalReceiverBase::m_rhead);
  if (rhs.Pending()) m_plink.InsertTail(this, &CTBsignalLink::m_plink,
                                        receiver.m_phead);
}

//------------------------------------------+-----------------------------------

CTBsignalLink::~CTBsignalLink()
{
  CTB_Trace("~CTBsignalLink()");
  
  assert(mi_nbusy == 0);                    // !?! must not be busy
  UnlinkEmitter();
  UnlinkReceiver();
}

//------------------------------------------+-----------------------------------

---