mitkMessage.h

Go to the documentation of this file.

/*=========================================================================

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision: 14123 $

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef mitkMessageHIncluded
#define mitkMessageHIncluded

#include <vector>
#include <itkSimpleFastMutexLock.h>

#define mitkNewMessageMacro(msgHandleObject)                                                                 \
  private: ::mitk::Message<> m_##msgHandleObject##Message;                                                   \
  public:                                                                                                \
  inline void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<>& delegate)              \
    { m_##msgHandleObject##Message += delegate; }                                                    \
  inline void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<>& delegate)           \
    { m_##msgHandleObject##Message -= delegate; }                                                    \


#define mitkNewMessageWithReturnMacro(msgHandleObject, returnType)                                                 \
  private: ::mitk::Message<returnType> m_##msgHandleObject##Message;                                               \
  public:                                                                                                      \
  inline void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<returnType>& delegate)          \
    { m_##msgHandleObject##Message += delegate; }                                                          \
    inline void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate<returnType>& delegate)     \
    { m_##msgHandleObject##Message -= delegate; }                                                          \


#define mitkNewMessage1Macro(msgHandleObject, type1)                                                          \
  private: ::mitk::Message1< type1 > m_##msgHandleObject##Message;                                                \
  public:                                                                                                 \
  void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate1< type1 >& delegate)              \
    { m_##msgHandleObject##Message += delegate; }                                                     \
    void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate1< type1 >& delegate)         \
    { m_##msgHandleObject##Message -= delegate; }

#define mitkNewMessage2Macro(msgHandleObject, type1, type2)                                                          \
  private: ::mitk::Message2< type1, type2 > m_##msgHandleObject##Message;                                                \
  public:                                                                                                 \
  void Add##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate2< type1, type2 >& delegate)              \
    { m_##msgHandleObject##Message += delegate; }                                                     \
    void Remove##msgHandleObject##Listener(const ::mitk::MessageAbstractDelegate2< type1, type2 >& delegate)         \
    { m_##msgHandleObject##Message -= delegate; }


namespace mitk {

template<typename A = void>
class MessageAbstractDelegate
{
  public:

    virtual ~MessageAbstractDelegate()
    {
    }

    virtual A Execute() = 0;
    virtual bool operator==(const MessageAbstractDelegate* cmd) = 0;
    virtual MessageAbstractDelegate* Clone() const = 0;
};


template <typename T, typename A = void>
class MessageAbstractDelegate1
{
  public:

    virtual ~MessageAbstractDelegate1()
    {
    }

    virtual A Execute(T t) = 0;
    virtual bool operator==(const MessageAbstractDelegate1* cmd) = 0;
    virtual MessageAbstractDelegate1* Clone() const = 0;
};

template <typename T, typename U, typename A = void>
class MessageAbstractDelegate2
{
  public:

    virtual ~MessageAbstractDelegate2()
    {
    }

    virtual A Execute(T t, U u) const = 0;
    virtual bool operator==(const MessageAbstractDelegate2* cmd) = 0;
    virtual MessageAbstractDelegate2* Clone() const = 0;
};

template <typename T, typename U, typename V, typename A = void>
class MessageAbstractDelegate3
{
  public:

    virtual ~MessageAbstractDelegate3()
    {
    }

    virtual A Execute(T t, U u, V v) const = 0;
    virtual bool operator==(const MessageAbstractDelegate3* cmd) = 0;
    virtual MessageAbstractDelegate3* Clone() const = 0;
};

template <typename T, typename U, typename V, typename W, typename A = void>
class MessageAbstractDelegate4
{
  public:

    virtual ~MessageAbstractDelegate4()
    {
    }

    virtual A Execute(T t, U u, V v, W w) const = 0;
    virtual bool operator==(const MessageAbstractDelegate4* cmd) = 0;
    virtual MessageAbstractDelegate4* Clone() const = 0;
};

template <class R, typename A = void>
class MessageDelegate : public MessageAbstractDelegate<A>
{
  public:

    // constructor - takes pointer to an object and pointer to a member and stores
    // them in two private variables
    MessageDelegate(R* object, A(R::*memberFunctionPointer)())
    :m_Object(object),
    m_MemberFunctionPointer(memberFunctionPointer)
    {
    }

    virtual ~MessageDelegate()
    {
    }

    // override function "Call"
    virtual A Execute()
    {
      return (m_Object->*m_MemberFunctionPointer)();    // execute member function
    }

    bool operator==(const MessageAbstractDelegate<A>* c)
    {
      const MessageDelegate<R,A>* cmd = dynamic_cast<const MessageDelegate<R,A>* >(c);
      if (!cmd) return false;

      if ((void*)this->m_Object != (void*)cmd->m_Object) return false;
      if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer) return false;
      return true;
    }

    MessageAbstractDelegate<A>* Clone() const
    {
      return new MessageDelegate(m_Object, m_MemberFunctionPointer);
    }

  private:
    R* m_Object;                            // pointer to object
    A (R::*m_MemberFunctionPointer)();   // pointer to member function
};


template <class R, typename T, typename A = void>
class MessageDelegate1 : public MessageAbstractDelegate1<T,A>
{
  public:

    // constructor - takes pointer to an object and pointer to a member and stores
    // them in two private variables
    MessageDelegate1(R* object, A(R::*memberFunctionPointer)(T))
    :m_Object(object),
    m_MemberFunctionPointer(memberFunctionPointer)
    {
    }

    virtual ~MessageDelegate1()
    {
    }

    // override function "Call"
    virtual A Execute(T t)
    {
      return (m_Object->*m_MemberFunctionPointer)(t);    // execute member function
    }

    bool operator==(const MessageAbstractDelegate1<T,A>* c)
    {
      const MessageDelegate1<R,T,A>* cmd = dynamic_cast<const MessageDelegate1<R,T,A>* >(c);
      if (!cmd) return false;

      if ((void*)this->m_Object != (void*)cmd->m_Object) return false;
      if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer) return false;
      return true;
    }

    MessageAbstractDelegate1<T,A>* Clone() const
    {
      return new MessageDelegate1(m_Object, m_MemberFunctionPointer);
    }

  private:
    R* m_Object;                          // pointer to object
    A (R::*m_MemberFunctionPointer)(T);   // pointer to member function
};


template <class R, typename T, typename U, typename A = void>
class MessageDelegate2 : public MessageAbstractDelegate2<T,U,A>
{
  public:

    // constructor - takes pointer to an object and pointer to a member and stores
    // them in two private variables
    MessageDelegate2(R* object, A(R::*memberFunctionPointer)(T, U))
    :m_Object(object),
    m_MemberFunctionPointer(memberFunctionPointer)
    {
    }

    virtual ~MessageDelegate2()
    {
    }

    // override function "Call"
    virtual A Execute(T t, U u) const
    {
      return (m_Object->*m_MemberFunctionPointer)(t,u);             // execute member function
    }

    bool operator==(const MessageAbstractDelegate2<T,U,A>* c)
    {
      const MessageDelegate2<R,T,U,A>* cmd = dynamic_cast<const MessageDelegate2<R,T,U,A>* >(c);
      if (!cmd) return false;

      if ((void*)this->m_Object != (void*)cmd->m_Object) return false;
      if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer) return false;
      return true;
    }

    MessageAbstractDelegate2<T,U,A>* Clone() const
    {
      return new MessageDelegate2(m_Object, m_MemberFunctionPointer);
    }

  private:
    R* m_Object;                            // pointer to object
    A (R::*m_MemberFunctionPointer)(T, U);   // pointer to member function
};

template <class R, typename T, typename U, typename V, typename A = void>
class MessageDelegate3 : public MessageAbstractDelegate3<T,U,V,A>
{
  public:

    // constructor - takes pointer to an object and pointer to a member and stores
    // them in two private variables
    MessageDelegate3(R* object, A(R::*memberFunctionPointer)(T, U, V))
    :m_Object(object),
    m_MemberFunctionPointer(memberFunctionPointer)
    {
    }

    virtual ~MessageDelegate3()
    {
    }

    // override function "Call"
    virtual A Execute(T t, U u, V v) const
    {
      return (m_Object->*m_MemberFunctionPointer)(t,u,v);             // execute member function
    }

    bool operator==(const MessageAbstractDelegate3<T,U,V,A>* c)
    {
      const MessageDelegate3<R,T,U,V,A>* cmd = dynamic_cast<const MessageDelegate3<R,T,U,V,A>* >(c);
      if (!cmd) return false;

      if ((void*)this->m_Object != (void*)cmd->m_Object) return false;
      if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer) return false;
      return true;
    }

    MessageAbstractDelegate3<T,U,V,A>* Clone() const
    {
      return new MessageDelegate3(m_Object, m_MemberFunctionPointer);
    }

  private:
    R* m_Object;                            // pointer to object
    A (R::*m_MemberFunctionPointer)(T, U, V);   // pointer to member function
};

template <class R, typename T, typename U, typename V, typename W, typename A = void>
class MessageDelegate4 : public MessageAbstractDelegate4<T,U,V,W,A>
{
  public:

    // constructor - takes pointer to an object and pointer to a member and stores
    // them in two private variables
    MessageDelegate4(R* object, A(R::*memberFunctionPointer)(T, U, V, W))
    :m_Object(object),
    m_MemberFunctionPointer(memberFunctionPointer)
    {
    }

    virtual ~MessageDelegate4()
    {
    }

    // override function "Call"
    virtual A Execute(T t, U u, V v, W w) const
    {
      return (m_Object->*m_MemberFunctionPointer)(t,u,v,w);             // execute member function
    }

    bool operator==(const MessageAbstractDelegate4<T,U,V,W,A>* c)
    {
      const MessageDelegate4<R,T,U,V,W,A>* cmd = dynamic_cast<const MessageDelegate4<R,T,U,V,W,A>* >(c);
      if (!cmd) return false;

      if ((void*)this->m_Object != (void*)cmd->m_Object) return false;
      if (this->m_MemberFunctionPointer != cmd->m_MemberFunctionPointer) return false;
      return true;
    }

    MessageAbstractDelegate4<T,U,V,W,A>* Clone() const
    {
      return new MessageDelegate4(m_Object, m_MemberFunctionPointer);
    }

  private:
    R* m_Object;                            // pointer to object
    A (R::*m_MemberFunctionPointer)(T, U, V, W);   // pointer to member function
};

template<typename A = void>
class Message
{
  public:

    typedef Message Self;
    typedef MessageAbstractDelegate<A> AbstractDelegate;
    typedef std::vector<AbstractDelegate* > ListenerList;

    ~Message() {
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end(); ++iter )
      {
        delete *iter;
      }
    }

    void AddListener( const AbstractDelegate& delegate ) const
    {
      AbstractDelegate* msgCmd = delegate.Clone();

      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(msgCmd)) {
          delete msgCmd;
          m_Mutex.Unlock();
          return;
        }
      }
      m_Listeners.push_back(msgCmd);
      m_Mutex.Unlock();
    }

    void operator += ( const AbstractDelegate& delegate ) const
    {
      this->AddListener(delegate);
    }

    void RemoveListener( const AbstractDelegate& delegate ) const
    {
      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(&delegate))
        {
          delete *iter;
          m_Listeners.erase( iter );
          m_Mutex.Unlock();
          return;
        }
      }
      m_Mutex.Unlock();
    }

    void operator -= ( const AbstractDelegate& delegate) const
    {
      this->RemoveListener(delegate);
    }

    void Send()
    {
      ListenerList listeners;

      {
        m_Mutex.Lock();
        listeners.assign(m_Listeners.begin(), m_Listeners.end());
        m_Mutex.Unlock();
      }

      for (typename ListenerList::iterator iter = listeners.begin();
            iter != listeners.end();
            ++iter )
      {
        // notify each listener
        (*iter)->Execute();
      }
    }

    void operator()()
    {
      this->Send();
    }

    const ListenerList& GetListeners() const
    {
      return m_Listeners;
    }

    bool HasListeners() const
    {
      return !m_Listeners.empty();
    }

    bool IsEmpty() const
    {
      return m_Listeners.empty();
    }

  protected:

    mutable ListenerList m_Listeners;
    mutable itk::SimpleFastMutexLock m_Mutex;

};


// message with 1 parameter and return type
template <typename T, typename A = void>
class Message1
{
  public:

    typedef Message1 Self;
    typedef MessageAbstractDelegate1<T,A> AbstractDelegate;
    typedef std::vector<AbstractDelegate*> ListenerList;

    ~Message1()
    {
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end(); ++iter )
      {
        delete *iter;
      }
    }

    void AddListener( const AbstractDelegate& delegate ) const
    {
      AbstractDelegate* msgCmd = delegate.Clone();

      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(msgCmd)) {
          delete msgCmd;
          m_Mutex.Unlock();
          return;
        }
      }
      m_Listeners.push_back(msgCmd);
      m_Mutex.Unlock();
    }

    void operator += ( const AbstractDelegate& delegate ) const
    {
      this->AddListener(delegate);
    }

    void RemoveListener( const AbstractDelegate& delegate ) const
    {
      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(&delegate))
        {
          delete *iter;
          m_Listeners.erase( iter );
          m_Mutex.Unlock();
          return;
        }
      }
      m_Mutex.Unlock();
    }

    void operator -= ( const AbstractDelegate& delegate) const
    {
      this->RemoveListener(delegate);
    }

    void Send(T t)
    {
      ListenerList listeners;

      {
        m_Mutex.Lock();
        listeners.assign(m_Listeners.begin(), m_Listeners.end());
        m_Mutex.Unlock();
      }

      for ( typename ListenerList::iterator iter = listeners.begin();
            iter != listeners.end();
            ++iter )
      {
        // notify each listener
        (*iter)->Execute(t);
      }
    }

    void operator()(T t)
    {
      this->Send(t);
    }

    const ListenerList& GetListeners() const
    {
      return m_Listeners;
    }

    bool HasListeners() const
    {
      return !m_Listeners.empty();
    }

    bool IsEmpty() const
    {
      return m_Listeners.empty();
    }

  protected:

    mutable ListenerList m_Listeners;
    mutable itk::SimpleFastMutexLock m_Mutex;

};


// message with 2 parameters and return type
template <typename T, typename U, typename A = void>
class Message2
{
  public:

    typedef Message2 Self;
    typedef MessageAbstractDelegate2<T,U,A> AbstractDelegate;
    typedef std::vector<AbstractDelegate* > ListenerList;

    ~Message2() {
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end(); ++iter )
      {
        delete *iter;
      }
    }

    void AddListener( const AbstractDelegate& delegate ) const
    {
      AbstractDelegate* msgCmd = delegate.Clone();

      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(msgCmd)) {
          delete msgCmd;
          m_Mutex.Unlock();
          return;
        }
      }
      m_Listeners.push_back(msgCmd);
      m_Mutex.Unlock();
    }

    void operator += ( const AbstractDelegate& delegate ) const
    {
      this->AddListener(delegate);
    }

    void RemoveListener( const AbstractDelegate& delegate ) const
    {
      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(&delegate))
        {
          delete *iter;
          m_Listeners.erase( iter );
          m_Mutex.Unlock();
          return;
        }
      }
      m_Mutex.Unlock();
    }

    void operator -= ( const AbstractDelegate& delegate) const
    {
      this->RemoveListener(delegate);
    }

    void Send(T t, U u)
    {
      ListenerList listeners;

      {
        m_Mutex.Lock();
        listeners.assign(m_Listeners.begin(), m_Listeners.end());
        m_Mutex.Unlock();
      }

      for ( typename ListenerList::iterator iter = listeners.begin();
            iter != listeners.end();
            ++iter )
      {
        // notify each listener
        (*iter)->Execute(t,u);
      }
    }

    void operator()(T t, U u)
    {
      this->Send(t, u);
    }

    const ListenerList& GetListeners() const
    {
      return m_Listeners;
    }

    bool HasListeners() const
    {
      return !m_Listeners.empty();
    }

    bool IsEmpty() const
    {
      return m_Listeners.empty();
    }

  protected:

    mutable ListenerList m_Listeners;
    mutable itk::SimpleFastMutexLock m_Mutex;

};

// message with 3 parameters and return type
template <typename T, typename U, typename V, typename A = void>
class Message3
{
  public:

    typedef Message3 Self;
    typedef MessageAbstractDelegate3<T,U,V,A> AbstractDelegate;
    typedef std::vector<AbstractDelegate* > ListenerList;

    ~Message3() {
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end(); ++iter )
      {
        delete *iter;
      }
    }

    void AddListener( const AbstractDelegate& delegate ) const
    {
      AbstractDelegate* msgCmd = delegate.Clone();

      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(msgCmd)) {
          delete msgCmd;
          m_Mutex.Unlock();
          return;
        }
      }
      m_Listeners.push_back(msgCmd);
      m_Mutex.Unlock();
    }

    void operator += ( const AbstractDelegate& delegate ) const
    {
      this->AddListener(delegate);
    }

    void RemoveListener(const AbstractDelegate& delegate ) const
    {
      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(&delegate))
        {
          delete *iter;
          m_Listeners.erase( iter );
          m_Mutex.Unlock();
          return;
        }
      }
      m_Mutex.Unlock();
    }

    void operator -= ( const AbstractDelegate& delegate) const
    {
      this->RemoveListener(delegate);
    }

    void Send(T t, U u, V v)
    {
      ListenerList listeners;

      {
        m_Mutex.Lock();
        listeners.assign(m_Listeners.begin(), m_Listeners.end());
        m_Mutex.Unlock();
      }

      for ( typename ListenerList::iterator iter = listeners.begin();
            iter != listeners.end();
            ++iter )
      {
        // notify each listener
        (*iter)->Execute(t,u,v);
      }
    }

    void operator()(T t, U u, V v)
    {
      this->Send(t, u, v);
    }

    const ListenerList& GetListeners() const
    {
      return m_Listeners;
    }

    bool HasListeners() const
    {
      return !m_Listeners.empty();
    }

    bool IsEmpty() const
    {
      return m_Listeners.empty();
    }

  protected:

    mutable ListenerList m_Listeners;
    mutable itk::SimpleFastMutexLock m_Mutex;

};

// message with 4 parameters and return type
template <typename T, typename U, typename V, typename W, typename A = void>
class Message4
{
  public:

    typedef Message4 Self;
    typedef MessageAbstractDelegate4<T,U,V,W,A> AbstractDelegate;
    typedef std::vector<AbstractDelegate* > ListenerList;

    ~Message4() {
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end(); ++iter )
      {
        delete *iter;
      }
    }

    void AddListener( const AbstractDelegate& delegate ) const
    {
      AbstractDelegate* msgCmd = delegate.Clone();

      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(msgCmd)) {
          delete msgCmd;
          m_Mutex.Unlock();
          return;
        }
      }
      m_Listeners.push_back(msgCmd);
      m_Mutex.Unlock();
    }

    void operator += ( const AbstractDelegate& delegate ) const
    {
      this->AddListener(delegate);
    }

    void RemoveListener( const AbstractDelegate& delegate ) const
    {
      m_Mutex.Lock();
      for (typename ListenerList::iterator iter = m_Listeners.begin();
           iter != m_Listeners.end();
           ++iter )
      {
        if ((*iter)->operator==(&delegate))
        {
          delete *iter;
          m_Listeners.erase( iter );
          m_Mutex.Unlock();
          return;
        }
      }
      m_Mutex.Unlock();
    }

    void operator -= ( const AbstractDelegate& delegate) const
    {
      this->RemoveListener(delegate);
    }

    void Send(T t, U u, V v, W w)
    {
      ListenerList listeners;

      {
        m_Mutex.Lock();
        listeners.assign(m_Listeners.begin(), m_Listeners.end());
        m_Mutex.Unlock();
      }

      for ( typename ListenerList::iterator iter = listeners.begin();
            iter != listeners.end();
            ++iter )
      {
        // notify each listener
        (*iter)->Execute(t,u,v,w);
      }
    }

    void operator()(T t, U u, V v, W w)
    {
      this->Send(t, u, v, w);
    }

    const ListenerList& GetListeners() const
    {
      return this->m_Listeners;
    }

    bool HasListeners() const
    {
      return !m_Listeners.empty();
    }

    bool IsEmpty() const
    {
      return m_Listeners.empty();
    }

  protected:

    mutable ListenerList m_Listeners;
    mutable itk::SimpleFastMutexLock m_Mutex;

};

} // namespace

#endif