notifier_ext.h

Go to the documentation of this file.

/*
 * notifier_ext.h
 *
 * Smart Notifiers and Notifier Lists
 *
 * Portable Windows Library
 *
 * Copyright (c) 2004 Reitek S.p.A.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): ______________________________________.
 */

#ifndef PTLIB_NOTIFIER_EXT_H
#define PTLIB_NOTIFIER_EXT_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <list>



typedef unsigned long PNotifierIdentifer;

class PValidatedNotifierTarget
{
  public:
    PValidatedNotifierTarget();
    virtual ~PValidatedNotifierTarget();

    // Do not copy the id across
    PValidatedNotifierTarget(const PValidatedNotifierTarget &);
    void operator=(const PValidatedNotifierTarget &) { }

    static bool Exists(PNotifierIdentifer id);

  private:
    PNotifierIdentifer m_validatedNotifierId;

  template <typename ParmType> friend class PValidatedNotifierFunction;
};


template <typename ParamType>
class PValidatedNotifierFunction : public PNotifierFunctionTemplate<ParamType>
{
  typedef PNotifierFunctionTemplate<ParamType> Parent;
  PCLASSINFO(PValidatedNotifierFunction, Parent);

  public:
    PValidatedNotifierFunction(void * voidTarget, PValidatedNotifierTarget * notifierTarget)
      : Parent(voidTarget)
      , m_targetID(notifierTarget->m_validatedNotifierId)
    { }

    virtual void * GetTarget() const
    {
      return PValidatedNotifierTarget::Exists(this->m_targetID) ? this->m_target : NULL;
    }

  protected:
    PNotifierIdentifer m_targetID;
};


#define PDECLARE_VALIDATED_NOTIFIER_EXT(notifierType, notifierArg, notifiee, func, ParamType, ParamArg) \
            PDECLARE_NOTIFIER_COMMON(notifierType, notifierArg, notifiee, func, ParamType, ParamArg, PValidatedNotifierFunction<ParamType>)

#define PDECLARE_VALIDATED_NOTIFIER2(notifierType,   notifiee, func, ParamType  ) \
     PDECLARE_VALIDATED_NOTIFIER_EXT(notifierType, , notifiee, func, ParamType, )

#define PDECLARE_VALIDATED_NOTIFIER(notifierType, notifiee, func) \
       PDECLARE_VALIDATED_NOTIFIER2(notifierType, notifiee, func, P_INT_PTR)



struct PAsyncNotifierCallback
{
  virtual ~PAsyncNotifierCallback() { }
  virtual void Call() = 0;

  static void Queue(PNotifierIdentifer id, PAsyncNotifierCallback * callback);
};


class PAsyncNotifierTarget
{
  public:
    PAsyncNotifierTarget();
    virtual ~PAsyncNotifierTarget();

    bool AsyncNotifierExecute(
      const PTimeInterval & wait = 0  
    );

    virtual void AsyncNotifierSignal();

  private:
    PNotifierIdentifer m_asyncNotifierId;

  template <typename ParmType> friend class PAsyncNotifierFunction;
};


template <typename ParamType>
class PAsyncNotifierFunction : public PNotifierFunctionTemplate<ParamType>
{
  typedef PNotifierFunctionTemplate<ParamType> Parent;
  PCLASSINFO(PAsyncNotifierFunction, Parent);

  public:
    PAsyncNotifierFunction(void * voidTarget, PAsyncNotifierTarget * notifierTarget)
      : Parent(voidTarget)
      , m_targetID(notifierTarget->m_asyncNotifierId)
    { }

  protected:
    PNotifierIdentifer m_targetID;

    template <class Target>
    class TypedCallback : public PAsyncNotifierCallback
    {
      private:
        const Target  & m_target;
        PObject       & m_notifier;
        ParamType       m_extra;

      public:
        TypedCallback(const Target & target, PObject & notifier, ParamType extra)
          : m_target(target)
          , m_notifier(notifier)
          , m_extra(extra)
        { }

        virtual void Call()
        {
          m_target.AsyncCall(m_notifier, m_extra);
        }
    };
};


#define PDECLARE_ASYNC_NOTIFIER_EXT(notifierType, notifierArg, notifiee, func, ParamType, ParamArg) \
       PDECLARE_NOTIFIER_COMMON1(notifierType, notifiee, func, ParamType, PAsyncNotifierFunction<ParamType>) \
       { PAsyncNotifierCallback::Queue(m_targetID, new TypedCallback<func##_PNotifier>(*this, note, extra)); } \
       void AsyncCall(PObject & note, ParamType extra) const \
       PDECLARE_NOTIFIER_COMMON2(notifierType, notifierArg, notifiee, func, ParamType, ParamArg, PAsyncNotifierFunction<ParamType>)

#define PDECLARE_ASYNC_NOTIFIER2(notifierType, notifiee, func, ParamType) \
       PDECLARE_ASYNC_NOTIFIER_EXT(notifierType, , notifiee, func, ParamType, )

#define PDECLARE_ASYNC_NOTIFIER(notifierType, notifiee, func) \
       PDECLARE_ASYNC_NOTIFIER2(notifierType, notifiee, func, P_INT_PTR)



template <typename ParamType>
class PNotifierListTemplate : public PObject
{
  PCLASSINFO(PNotifierListTemplate, PObject);
  private:
    typedef PNotifierTemplate<ParamType> Notifier;
    typedef std::list<Notifier> List;
    List m_list;

  public:
    PINDEX GetSize() const { return this->m_list.size(); }

    bool Add(const Notifier & handler)
    {
        if (std::find(this->m_list.begin(), this->m_list.end(), handler) != this->m_list.end())
            return false;
        this->m_list.push_back(handler);
        return true;
    }

    bool Remove(const Notifier & handler)
    {
      typename List::iterator it = std::find(this->m_list.begin(), this->m_list.end(), handler);
      if (it == this->m_list.end())
          return false;
      this->m_list.erase(it);
      return true;
    }

    bool Contains(const Notifier & handler) const
    {
      return std::find(this->m_list.begin(), this->m_list.end(), handler) != this->m_list.end();
    }

    bool IsEmpty() const
    {
      return this->m_list.empty();
    }

    struct IsTarget : public std::unary_function<PObject, bool> 
    {
      PObject * m_obj;
      IsTarget(PObject * obj) : m_obj(obj) { }
      bool operator()(Notifier & test) const { return m_obj == test.GetTarget(); }
    };

    void RemoveTarget(PObject * obj)
    {
      this->m_list.remove_if(IsTarget(obj));
    }

    bool operator()(PObject & obj, ParamType param)
    {
      if (this->m_list.empty())
        return false;
      for (typename List::iterator it = this->m_list.begin(); it != this->m_list.end() ; ++it)
        (*it)(obj, param);
      return true;
    }
};

typedef PNotifierListTemplate<P_INT_PTR> PNotifierList;


#endif  // PTLIB_NOTIFIER_EXT_H


// End of File ///////////////////////////////////////////////////////////////