/**
 * callback.C: C++ callback mechanism
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Copyright © 2007 Pippijn van Steenhoven
 */

static char const rcsid[] = "$Id";

#include <svsconfig.h>
#include <common/callback.h>

has_callbacks::callbacks has_callbacks::callback;

has_callbacks::has_callbacks ()
{
  callback.created (this);
}

has_callbacks::~has_callbacks ()
{
  callback.destroyed (this);
}

namespace callback
{
  has_listeners::has_listeners ()
  {
  }
  
  has_listeners::~has_listeners ()
  {
    disconnect_all ();
  }
  
  has_listeners::sender_set &
  has_listeners::invokers ()
  {
    return this->m_senders;
  }
  
  const has_listeners::sender_set &
  has_listeners::invokers () const
  {
    return this->m_senders;
  }
  
  
  has_listeners::has_listeners (const has_listeners &rhs)
  {
    this->copy_invokers (rhs);
  }
  
  has_listeners &
  has_listeners::operator = (const has_listeners &rhs)
  {
    this->disconnect_all ();
    this->copy_invokers (rhs);
    return *this;
  }
  
  void
  has_listeners::add_invoker (event_base * sender)
  {
    this->invokers ().insert (sender);
  }
  
  void
  has_listeners::remove_invoker (event_base * sender)
  {
    this->invokers ().erase (sender);
  }
  
  void
  has_listeners::copy_invokers (const has_listeners &rhs)
  {
    if (&rhs == this)
      return;
    
    const_iterator it;
    const_iterator itEnd = rhs.invokers ().end ();
    
    for (it = rhs.invokers ().begin (); it != itEnd; ++it)
      {
        (*it)->listener_duplicate (&rhs, this);
        this->invokers ().insert (*it);
      }
  }
  
  void
  has_listeners::disconnect_all ()
  {
    iterator it;
    iterator et = this->invokers ().end ();
    
    for (it = this->invokers ().begin (); et != it; ++it)
      (*it)->detach (this);
    
    this->invokers ().clear ();
  }
} // namespace callback