notifierwithparameter.h

C++封装的视频采集代码

/***************************************************************************
 *
 *  Oxford Semiconductor Proprietary and Confidential Information
 *
 *  Copyright:      Oxford Semiconductor Ltd, 2003
 *
 *  Description:
 *
 *  $Log: NotifierWithParameter.h,v $
 *  Revision 1.8  2004/06/28 14:02:11  clarke
 *  Fixed bugzilla bugs 348, 349, 350, 375, moved Vector from Misc to Utils, added initial support for signals for Tao port work - known issue with not clearing pending signal flag
 *
 *  Revision 1.7  2004/06/15 10:16:52  ford
 *  efficiency and definition changes.
 *
 *  Revision 1.6  2004/01/09 12:44:38  clarke
 *  Support IIB stats gathering
 *
 *  Revision 1.5  2003/09/23 08:00:15  paul
 *  *** empty log message ***
 *
 ***************************************************************************/


#ifndef NOTIFIER_WITH_PARAMETER_H
#define NOTIFIER_WITH_PARAMETER_H

#include "SysLib/Lock.h"
#include "Utils/Vector.h"
#include "SysLib/oxsemi_sem.h"
#include <algorithm>
#include <functional>
#include <utility>

namespace oxsemi
{
    template <typename T, typename U> class NotifierWithParameter
    {
    public:
        virtual ~NotifierWithParameter() = 0;

        bool AddListener(T* listener);

        void RemoveListener(T* listener);

    protected:
        explicit NotifierWithParameter(unsigned maxListeners);

        void NotifyListeners(const U& parameter);

        virtual void DoNotify(T* listener, const U& parameter) = 0;

        typename Vector<T*>::size_type GetNumberOfListeners();

    private:
        template <typename V, typename W> class NotifyFunctorWithParameter :
            public std::unary_function<V*, void>
        {
        public:
            NotifyFunctorWithParameter<V, W>(NotifierWithParameter<V, W>* notifier, const W& parameter) :
                notifier_(notifier),
                parameter_(parameter)
            {
            }

            void operator()(V* listener)
            {
                notifier_->DoNotify(listener, parameter_);
            }

        private:
            NotifierWithParameter<V, W>* notifier_;
            W parameter_;
        };

        typedef Vector<T*> ListenerContainerType;

        syslib::oxsemi_bsem semaphore_;
        ListenerContainerType listeners_;
    };

    template<typename T, typename U> NotifierWithParameter<T, U>::NotifierWithParameter(unsigned maxListeners) :
        listeners_(maxListeners)
    {
    }

    template <typename T, typename U> NotifierWithParameter<T, U>::~NotifierWithParameter()
    {
    }

    template<typename T, typename U> inline bool NotifierWithParameter<T, U>::AddListener(T* listener)
    {
        bool status = true;

        syslib::Lock lock(semaphore_);
        if (listeners_.size() >= listeners_.max_size())
        {
            status = false;
        }
        else
        {
            listeners_.insert(std::lower_bound(listeners_.begin(), listeners_.end(), listener), listener);
        }
        return status;
    }

    template<typename T, typename U> inline typename Vector<T*>::size_type NotifierWithParameter<T, U>::GetNumberOfListeners()
    {
        syslib::Lock lock(semaphore_);
        return listeners_.size();
    }

    template<typename T, typename U> inline void NotifierWithParameter<T, U>::NotifyListeners(const U& parameter)
    {
        syslib::Lock lock(semaphore_);
        std::for_each(listeners_.begin(),
                      listeners_.end(),
                      NotifyFunctorWithParameter<T, U>(this, parameter));
    }

    template<typename T, typename U> inline void NotifierWithParameter<T, U>::RemoveListener(T* listener)
    {
        if ( !listener )
        {
            // nothing to remove.
            return;
        }
        
        syslib::Lock lock(semaphore_);
        if (listeners_.size() > 0)
        {
            std::pair<typename ListenerContainerType::iterator, typename ListenerContainerType::iterator> searchResult =
                std::equal_range(listeners_.begin(), listeners_.end(), listener);

            if (searchResult.first != searchResult.second)
            {
                listeners_.erase(searchResult.first);
            }
        }
    }
}
#endif