Event.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2011, SRI International (R)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef __OpenKarto_Event_h__
#define __OpenKarto_Event_h__

#include <OpenKarto/List.h>
#include <OpenKarto/Mutex.h>

// Forward declaration for tbb::mutex
namespace tbb
{
  class mutex;
}

namespace karto
{


  // The following code is from the Poco library with the following license 
  // and modified to fit into the KartoSDK

  // Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
  // and Contributors.
  //
  // Permission is hereby granted, free of charge, to any person or organization
  // obtaining a copy of the software and accompanying documentation covered by
  // this license (the "Software") to use, reproduce, display, distribute,
  // execute, and transmit the Software, and to prepare derivative works of the
  // Software, and to permit third-parties to whom the Software is furnished to
  // do so, all subject to the following:
  // 
  // The copyright notices in the Software and this entire statement, including
  // the above license grant, this restriction and the following disclaimer,
  // must be included in all copies of the Software, in whole or in part, and
  // all derivative works of the Software, unless such copies or derivative
  // works are solely in the form of machine-executable object code generated by
  // a source language processor.
  // 
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  // FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
  // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
  // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
  // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  // DEALINGS IN THE SOFTWARE.




  //@cond EXCLUDE

  template <class TArgs> 
  class AbstractDelegate
  {
  public:
    AbstractDelegate(void* pTarget)
      : m_pTarget(pTarget)
    {
      assert(m_pTarget != 0);
    }

    AbstractDelegate(const AbstractDelegate& rOther)
      : m_pTarget(rOther.m_pTarget)
    {
      assert(m_pTarget != 0);
    }

    virtual ~AbstractDelegate() 
    {
    }

  public:
    virtual void Notify(const void* pSender, TArgs& rArguments) = 0;

    virtual AbstractDelegate* Clone() const = 0;

    void* GetTarget() const
    {
      return m_pTarget;
    }

  public:
    kt_bool operator==(const AbstractDelegate<TArgs>& rOther) const
    {
      return m_pTarget == rOther.m_pTarget;
    }

    kt_bool operator<(const AbstractDelegate<TArgs>& rOther) const
    {
      return m_pTarget < rOther.m_pTarget;
    }

  protected:
    void* m_pTarget;
  };


  template <class TObj, class TArgs, bool withSender=true> 
  class Delegate: public AbstractDelegate<TArgs>
  {
  public:
    typedef void (TObj::*NotifyMethod)(const void*, TArgs&);

    Delegate(TObj* pObject, NotifyMethod method)
      : AbstractDelegate<TArgs>(pObject)
      , m_ReceiverObject(pObject)
      , m_ReceiverMethod(method)
    {
    }

    Delegate(const Delegate& rDelegate)
      : AbstractDelegate<TArgs>(rDelegate)
      , m_ReceiverObject(rDelegate.m_ReceiverObject)
      , m_ReceiverMethod(rDelegate.m_ReceiverMethod)
    {
    }

    virtual ~Delegate()
    {
    }

  public:
    void Notify(const void* pSender, TArgs& rArguments)
    {
      (m_ReceiverObject->*m_ReceiverMethod)(pSender, rArguments);
    }

    AbstractDelegate<TArgs>* Clone() const
    {
      return new Delegate(*this);
    }

  public:
    Delegate& operator=(const Delegate& rOther)
    {
      if (&rOther != this)
      {
        this->m_pTarget        = rOther.m_pTarget;
        this->m_ReceiverObject = rOther.m_ReceiverObject;
        this->m_ReceiverMethod = rOther.m_ReceiverMethod;
      }
      return *this;
    }

  protected:
    TObj*        m_ReceiverObject;
    NotifyMethod m_ReceiverMethod;

  private:
    Delegate();
  };


  template <class TObj, class TArgs> 
  class Delegate<TObj, TArgs, false>: public AbstractDelegate<TArgs>
  {
  public:
    typedef void (TObj::*NotifyMethod)(TArgs&);

    Delegate(TObj* pObject, NotifyMethod method)
      : AbstractDelegate<TArgs>(pObject)
      , m_ReceiverObject(pObject)
      , m_ReceiverMethod(method)
    {
    }

    Delegate(const Delegate& rDelegate)
      : AbstractDelegate<TArgs>(rDelegate)
      , m_ReceiverObject(rDelegate.m_ReceiverObject)
      , m_ReceiverMethod(rDelegate.m_ReceiverMethod)
    {
    }

    virtual ~Delegate()
    {
    }

  public:
    void Notify(const void*, TArgs& rArguments)
    {
      (m_ReceiverObject->*m_ReceiverMethod)(rArguments);
    }

    AbstractDelegate<TArgs>* Clone() const
    {
      return new Delegate(*this);
    }

  public:
    Delegate& operator=(const Delegate& rOther)
    {
      if (&rOther != this)
      {
        this->m_pTarget        = rOther.m_pTarget;
        this->m_ReceiverObject = rOther.m_ReceiverObject;
        this->m_ReceiverMethod = rOther.m_ReceiverMethod;
      }

      return *this;
    }

  protected:
    TObj*        m_ReceiverObject;
    NotifyMethod m_ReceiverMethod;

  private:
    Delegate();
  };


  template <class TArgs, bool hasSender = true, bool senderIsConst = true> 
  class FunctionDelegate: public AbstractDelegate<TArgs>
  {
  public:
    typedef void (*NotifyMethod)(const void*, TArgs&);

    FunctionDelegate(NotifyMethod method)
      : AbstractDelegate<TArgs>(*reinterpret_cast<void**>(&method))
      , m_ReceiverMethod(method)
    {
    }

    FunctionDelegate(const FunctionDelegate& rOther)
      : AbstractDelegate<TArgs>(rOther)
      , m_ReceiverMethod(rOther.m_ReceiverMethod)
    {
    }

    virtual ~FunctionDelegate()
    {
    }

  public:
    void Notify(const void* pSender, TArgs& rArguments)
    {
      (*m_ReceiverMethod)(pSender, rArguments);
    }

    AbstractDelegate<TArgs>* Clone() const
    {
      return new FunctionDelegate(*this);
    }

  public:
    FunctionDelegate& operator=(const FunctionDelegate& rOther)
    {
      if (&rOther != this)
      {
        this->m_pTarget        = rOther.m_pTarget;
        this->m_ReceiverMethod = rOther.m_ReceiverMethod;
      }
      return *this;
    }

  protected:
    NotifyMethod m_ReceiverMethod;

  private:
    FunctionDelegate();
  };


  template <class TArgs> 
  class FunctionDelegate<TArgs, true, false>: public AbstractDelegate<TArgs>
  {
  public:
    typedef void (*NotifyMethod)(void*, TArgs&);

    FunctionDelegate(NotifyMethod method)
      : AbstractDelegate<TArgs>(*reinterpret_cast<void**>(&method))
      , m_ReceiverMethod(method)
    {
    }

    FunctionDelegate(const FunctionDelegate& rOther)
      : AbstractDelegate<TArgs>(rOther)
      , m_ReceiverMethod(rOther.m_ReceiverMethod)
    {
    }

    virtual ~FunctionDelegate()
    {
    }

  public:
    void Notify(const void* pSender, TArgs& rArguments)
    {
      (*m_ReceiverMethod)(const_cast<void*>(pSender), rArguments);
    }

    AbstractDelegate<TArgs>* Clone() const
    {
      return new FunctionDelegate(*this);
    }

  public:
    FunctionDelegate& operator=(const FunctionDelegate& rOther)
    {
      if (&rOther != this)
      {
        this->m_pTarget        = rOther.m_pTarget;
        this->m_ReceiverMethod = rOther.m_ReceiverMethod;
      }
      return *this;
    }

  protected:
    NotifyMethod m_ReceiverMethod;

  private:
    FunctionDelegate();
  };


  template <class TArgs, bool senderIsConst> 
  class FunctionDelegate<TArgs, false, senderIsConst>: public AbstractDelegate<TArgs>
  {
  public:
    typedef void (*NotifyMethod)(TArgs&);

    FunctionDelegate(NotifyMethod method)
      : AbstractDelegate<TArgs>(*reinterpret_cast<void**>(&method))
      , m_ReceiverMethod(method)
    {
    }

    FunctionDelegate(const FunctionDelegate& rOther)
      : AbstractDelegate<TArgs>(rOther)
      , m_ReceiverMethod(rOther.m_ReceiverMethod)
    {
    }

    virtual ~FunctionDelegate()
    {
    }

  public:
    void Notify(const void* /*pSender*/, TArgs& rArguments)
    {
      (*m_ReceiverMethod)(rArguments);
    }

    AbstractDelegate<TArgs>* Clone() const
    {
      return new FunctionDelegate(*this);
    }

  public:
    FunctionDelegate& operator=(const FunctionDelegate& rOther)
    {
      if (&rOther != this)
      {
        this->m_pTarget        = rOther.m_pTarget;
        this->m_ReceiverMethod = rOther.m_ReceiverMethod;
      }
      return *this;
    }

  protected:
    NotifyMethod m_ReceiverMethod;

  private:
    FunctionDelegate();
  };


  template <class TArgs> 
  class NotificationStrategy
  {
  public:
    NotificationStrategy()
    {
    }

    virtual ~NotificationStrategy()
    {
    }

  public:
    virtual void Notify(const void* sender, TArgs& arguments) = 0;

    virtual void Add(const AbstractDelegate<TArgs>& pDelegate) = 0;

    virtual void Remove(const AbstractDelegate<TArgs>& pDelegate) = 0;

    virtual void Clear() = 0;

    virtual bool IsEmpty() const = 0;
  };


  template <class TArgs> 
  class DefaultStrategy : public NotificationStrategy<TArgs>
  {
  public:
    typedef karto::List< AbstractDelegate<TArgs>* > DelegateList;

  public:
    DefaultStrategy()
    {
    }

    DefaultStrategy(const DefaultStrategy& rOther)
    {
      operator = (rOther);
    }

    virtual ~DefaultStrategy()
    {
      Clear();
    }

  public:
    void Notify(const void* pSender, TArgs& rArguments)
    {
      karto_forEach(typename DelegateList, &m_Observers)
      {
        (*iter)->Notify(pSender, rArguments);
      }
    }

    void Add(const AbstractDelegate<TArgs>& rDelegate)
    {
      Remove(rDelegate);

      AbstractDelegate<TArgs>* pDelegate = rDelegate.Clone();
      m_Observers.Add(pDelegate);
    }

    void Remove(const AbstractDelegate<TArgs>& rDelegate)
    {
      kt_bool found = false;
      kt_int32s index = 0;
      karto_forEach(typename DelegateList, &m_Observers)
      {
        if (*(*iter) == rDelegate)
        {
          delete *iter;
          found = true;
          break;
        }

        index++;
      }

      if (found == true)
      {
        m_Observers.RemoveAt(index);
      }
    }

    void Clear()
    {
      karto_forEach(typename DelegateList, &m_Observers)
      {
        delete *iter;
      }
      m_Observers.Clear();
    }

    kt_bool IsEmpty() const
    {
      return m_Observers.IsEmpty();
    }

  public:
    DefaultStrategy& operator=(const DefaultStrategy& rOther)
    {
      if (this != &rOther)
      {
        karto_const_forEach(typename DelegateList, &(rOther.m_Observers))
        {
          Add(**iter);
        }
      }
      return *this;
    }

  protected:
    DelegateList m_Observers;
  };
  
  // @endcond


  template <class TArgs> 
  class AbstractEvent
  {
  public:
    AbstractEvent()
      : m_Enabled(true)
    {
    }

    AbstractEvent(const DefaultStrategy<TArgs>& rStrategy)
      : m_Enabled(true)
      , m_Strategy(rStrategy)
    {
    }

    virtual ~AbstractEvent()
    {
    }

    void operator+=(const AbstractDelegate<TArgs>& rDelegate)
    {
      Mutex::ScopedLock lock(m_Mutex);
      m_Strategy.Add(rDelegate);
    }

    void operator-=(const AbstractDelegate<TArgs>& rDelegate)
    {
      Mutex::ScopedLock lock(m_Mutex);
      m_Strategy.Remove(rDelegate);
    }

    void operator()(const void* pSender, TArgs& args)
    {
      Notify(pSender, args);
    }

    void Notify(const void* pSender, TArgs& rArgs)
    {
      DefaultStrategy<TArgs>* pStrats = NULL;
      kt_bool enabled = false;

      {
        Mutex::ScopedLock lock(m_Mutex);
        enabled = m_Enabled;

        if (m_Enabled)
        {
          // thread-safeness: 
          // copy should be faster and safer than blocking until execution ends
          pStrats = new DefaultStrategy<TArgs>(m_Strategy);
        }
      }

      if (enabled)
      {
        pStrats->Notify(pSender, rArgs);
      }

      delete pStrats;
    }

    void Enable()
    {
      Mutex::ScopedLock lock(m_Mutex);
      m_Enabled = true;
    }

    void Disable()
    {
      Mutex::ScopedLock lock(m_Mutex);
      m_Enabled = false;
    }

    kt_bool IsEnabled() const
    {
      Mutex::ScopedLock lock(m_Mutex);
      return m_Enabled;
    }

    void Clear()
    {
      Mutex::ScopedLock lock(m_Mutex);
      m_Strategy.Clear();
    }

    kt_bool IsEmpty() const
    {
      Mutex::ScopedLock lock(m_Mutex);
      return m_Strategy.IsEmpty();
    }

  protected:
    kt_bool m_Enabled; 

    DefaultStrategy<TArgs> m_Strategy; 

    mutable Mutex m_Mutex;

  private:
    AbstractEvent(const AbstractEvent& rOther);
    AbstractEvent& operator=(const AbstractEvent& rOther);
  };

  
  template <class TArgs> 
  class BasicEvent : public AbstractEvent <TArgs >
  {
  public:
    BasicEvent()
    {
    }

    virtual ~BasicEvent()
    {
    }

  private:
    BasicEvent(const BasicEvent& e);
    BasicEvent& operator=(const BasicEvent& e);
  };


  class KARTO_EXPORT EventArguments
  {
  public:
    EventArguments();
    virtual ~EventArguments();

  public:
    static EventArguments& Empty()
    {
      static EventArguments dummy;

      return dummy;
    }
  }; // class EventArguments

#ifdef WIN32
#define EXPORT_KARTO_EVENT(declspec, T) \
  template class declspec karto::BasicEvent<T>;

  EXPORT_KARTO_EVENT(KARTO_EXPORT, EventArguments)
#endif


  template <class TObj, class TArgs>
  static Delegate<TObj, TArgs, true> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&))
  {
    return Delegate<TObj, TArgs, true>(pObj, NotifyMethod);
  }

  template <class TObj, class TArgs>
  static Delegate<TObj, TArgs, false> delegate(TObj* pObj, void (TObj::*NotifyMethod)(TArgs&))
  {
    return Delegate<TObj, TArgs, false>(pObj, NotifyMethod);
  }

  template <class TArgs>
  static FunctionDelegate<TArgs, true, true> delegate(void (*NotifyMethod)(const void*, TArgs&))
  {
    return FunctionDelegate<TArgs, true, true>(NotifyMethod);
  }

  template <class TArgs>
  static FunctionDelegate<TArgs, true, false> delegate(void (*NotifyMethod)(void*, TArgs&))
  {
    return FunctionDelegate<TArgs, true, false>(NotifyMethod);
  }

  template <class TArgs>
  static FunctionDelegate<TArgs, false> delegate(void (*NotifyMethod)(TArgs&))
  {
    return FunctionDelegate<TArgs, false>(NotifyMethod);
  }


}

#endif // __OpenKarto_Event_h__