---

CTBcallbackBase.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 "CTBcallbackBase.hxx"

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

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

  while(m_shead) {
    CTBcallbackLink* p_link = m_shead.First();
    
    if (p_link->Busy()) {
      p_link->UnlinkSource();
    } else {
      delete p_link;
    }
  }
}

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

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

  int i_nconnect = 0;
  
  for(CTBcallbackLink* p_link = m_shead.First(); p_link;
                       p_link = p_link->m_slink.Next()) {
    if (!p_link->Zombie()) i_nconnect++;
  }
  
  return i_nconnect;
}

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

void CTBcallbackSourceBase::Execute(void* p_arg) const
{
  CTB_Trace("CTBcallbackSourceBase::Execute(void*)");

  for(CTBcallbackLink* p_link = m_shead.First(); p_link; ) {
    CTBcallbackLink* p_next = p_link->m_slink.Next();

    if (!p_link->Zombie()) {                // if not marked for delete
      p_link->Mark();                       // lock link against deletion
      try {
        p_link->m_tlink.Parent()->Execute(p_arg); // DO IT !!

      } catch(...) {                        // in case of exception
        p_link->Unmark();                   // unlock
        if (p_link->Deletable()) delete p_link; // burry zombie if possible
        throw;                              // and rethrow
      }

      p_link->Unmark();                     // unlock
      p_next = p_link->m_slink.Next();      // re-evaluate in case of deletions
      if (p_link->Deletable()) delete p_link; // burry zombie if possible
    }

    p_link = p_next;
  }

  return;
}

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

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

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

  Disconnect();
}

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

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

  int i_nconnect = 0;
  
  for(CTBcallbackLink* p_link = m_thead.First(); p_link;
                       p_link = p_link->m_tlink.Next()) {
    if (!p_link->Zombie()) i_nconnect++;
  }
  
  return i_nconnect;
}

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

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

  while (m_thead) {
    CTBcallbackLink* p_link = m_thead.First();
    
    if (p_link->Busy()) {
      p_link->UnlinkTarget();
    } else {
      delete p_link;
    }
  }
  
  return;
}

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

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

  if (this == &rhs) return *this;
  
  Disconnect();
  
  for (CTBcallbackLink* p_link = rhs.m_thead.First(); p_link;
       p_link = p_link->m_tlink.Next()) {
    if (!p_link->Zombie()) {
      new CTBcallbackLink(*this,*(p_link->m_slink.Head()));
    }
  }
  
  return *this;
}

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

void CTBcallbackTargetBase::Connect(CTBcallbackSourceBase& source)
{
  CTB_Trace("CTBcallbackTargetBase::Connect(CTBcallbackSourceBase&)");

  new CTBcallbackLink(*this, source);
  return;
}

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

void CTBcallbackTargetBase::Disconnect(CTBcallbackSourceBase& source)
{
  CTB_Trace("CTBcallbackTargetBase::Disconnect(CTBcallbackSourceBase&)");

  for (CTBcallbackLink* p_link = m_thead.First(); p_link; ) {
    CTBcallbackLink* p_next = p_link->m_tlink.Next();

    if (p_link->m_slink.Head() == &source.m_shead) {
      if (p_link->Busy()) {
        p_link->UnlinkTarget();
      } else {
        delete p_link;
      }
    }
    p_link = p_next;
  }
  
  return;
}

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

#ifdef DEV_DOCS

#endif

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

CTBcallbackLink::CTBcallbackLink(CTBcallbackTargetBase& target,
                                 CTBcallbackSourceBase& source)
  : m_slink(),
    m_tlink(),
    mi_nbusy(0)
{
  CTB_Trace("CTBcallbackLink(CTBcallbackTargetBase&, CTBcallbackSourceBase&)");

  m_slink.InsertTail(this, &CTBcallbackLink::m_slink, source.m_shead);
  m_tlink.InsertTail(this, &CTBcallbackLink::m_tlink, 
                     target, &CTBcallbackTargetBase::m_thead);
}

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

CTBcallbackLink::CTBcallbackLink(CTBcallbackTargetBase& target,
                                 CTBsimpleListHead<CTBcallbackLink>& shead)
  : m_slink(),
    m_tlink(),
    mi_nbusy(0)
{
  CTB_Trace("CTBcallbackLink(CTBcallbackTargetBase&, CTBsimpleListHead<CTBcallbackLink>&)");

  m_slink.InsertTail(this, &CTBcallbackLink::m_slink, shead);
  m_tlink.InsertTail(this, &CTBcallbackLink::m_tlink, 
                     target, &CTBcallbackTargetBase::m_thead);
}

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

CTBcallbackLink::~CTBcallbackLink()
{
  CTB_Trace("~CTBcallbackLink()");
  
  assert(mi_nbusy == 0);                    // !?! must not be busy
  UnlinkSource();
  UnlinkTarget();
}

---