observer.hpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

////////////////////////////////////////////////////////////////////////////////

#ifndef MORE_UTIL_OBSERVER_HPP
#define MORE_UTIL_OBSERVER_HPP

////////////////////////////////////////////////////////////////////////////////

#include <more/create.hpp>
#include <more/pointer.hpp>
#include <more/synchronized.hpp>
#include <more/util/vector.hpp>

////////////////////////////////////////////////////////////////////////////////

namespace more
{
  namespace util
  {
    class ObserverHandle
    {
      public:
        virtual void removeObserver( ) = 0;

      protected:
        virtual ~ObserverHandle( );
    };


    template<typename Observer>
    class EventAdapter
    {
      public:
        virtual void updateObserver( const p<Observer>& ) = 0;

      protected:
        virtual ~EventAdapter( );
    };


    template<typename Observer>
    class EventDistributor
    {
      public:
        EventDistributor( );
        p<ObserverHandle> addObserver( const p<EventAdapter<Observer> >&, const p<Observer>& );
        void updateObservers( const p<EventAdapter<Observer> >& );
        void destroy( const p<EventAdapter<Observer> >& );

      protected:
        virtual ~EventDistributor( );

      private:
        p<more::os::Mutex> m_pMutex;
        p<Vector<p<Observer> > > m_pObservers;
    };


    template<typename Observer>
    class ObserverHandleImpl: public ObserverHandle
    {
      public:
        ObserverHandleImpl( const p<Vector<p<Observer> > >&, const p<Observer>& );
        virtual void removeObserver( );

      private:
        p<Vector<p<Observer> > > m_pObservers;
        p<Observer> m_pObserver;
    };
  }
}

////////////////////////////////////////////////////////////////////////////////

inline more::util::ObserverHandle::~ObserverHandle( )
{
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline more::util::EventAdapter<Observer>::~EventAdapter( )
{
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline more::util::EventDistributor<Observer>::EventDistributor( )
{
  m_pMutex = more::os::Mutex::create( );
  m_pObservers = CREATE Vector<p<Observer> >( );
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline more::p<more::util::ObserverHandle> more::util::EventDistributor<Observer>::addObserver
(
  const p<EventAdapter<Observer> >& pEventAdapter,
  const p<Observer>&                pObserver
)
{
  synchronized( m_pMutex )
  {
    pEventAdapter -> updateObserver( pObserver );

  } end_synchronized

  return CREATE ObserverHandleImpl<Observer>( m_pObservers, pObserver );
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline void more::util::EventDistributor<Observer>::updateObservers
(
  const p<EventAdapter<Observer> >& pEventAdapter
)
{
  synchronized( m_pMutex )
  {
    Array<p<Observer> > observers = m_pObservers -> toArray( );

    for( size_t i = 0; i < observers.getLength( ); i++ )
    {
      pEventAdapter -> updateObserver( observers[i] );
    }

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline void more::util::EventDistributor<Observer>::destroy
(
  const p<EventAdapter<Observer> >& pEventAdapter
)
{
  synchronized( m_pMutex )
  {
    Array<p<Observer> > observers = m_pObservers -> toArray( true );

    for( size_t i = 0; i < observers.getLength( ); i++ )
    {
      pEventAdapter -> updateObserver( observers[i] );
    }

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline more::util::EventDistributor<Observer>::~EventDistributor( )
{
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline more::util::ObserverHandleImpl<Observer>::ObserverHandleImpl
(
  const p<Vector<p<Observer> > >& pObservers,
  const p<Observer>&              pObserver
)
: m_pObservers( pObservers ), m_pObserver( pObserver )
{
  m_pObservers -> add( m_pObserver );
}

////////////////////////////////////////////////////////////////////////////////

template<typename Observer>
inline void more::util::ObserverHandleImpl<Observer>::removeObserver( )
{
  m_pObservers -> remove( m_pObserver );
}

////////////////////////////////////////////////////////////////////////////////

#endif