include/PureMVC/Patterns/Observer/Observer.hpp

Go to the documentation of this file.

//  Observer.hpp
//  PureMVC_C++
//
//  PureMVC Port to C++ by Tang Khai Phuong <phuong.tang@puremvc.org>
//  PureMVC - Copyright(c) 2006-2011 Futurescale, Inc., Some rights reserved.
//  Your reuse is governed by the Creative Commons Attribution 3.0 License
//

#if !defined(__PUREMVC_PATTERNS_OBSERVER_OBSERVER_HPP__)
#define __PUREMVC_PATTERNS_OBSERVER_OBSERVER_HPP__

// STL include
#include <stdexcept>
#include <exception>
// PureMVC include
#if !defined(__PUREMVC_HPP__)
#define __PUREMVC_INCLUDE__
#include "../PureMVC.hpp"
#endif /* __PUREMVC_HPP__ */

#include "../../Interfaces/IObserver.hpp"

#pragma pack(push)
#pragma pack(4)

namespace PureMVC
{
    namespace Patterns
    {
        using Interfaces::IObserver;

        template<typename _Method, typename _Context>
        class Observer : public IObserver
        {
        private:
            Observer(void);
        public:
            explicit Observer(Observer const& arg)
            :IObserver()
            ,_notify_method(arg._notify_method)
            ,_notify_context(arg._notify_context)
            { }

        public:
            explicit Observer(_Method notify_method, _Context* notify_context)
            :IObserver()
            ,_notify_method(notify_method)
            ,_notify_context(notify_context)
            ,_removed(false)
            { }

            virtual void notifyObserver(INotification const& notification)
            {
                if (_notify_context == NULL)
                    throw std::runtime_error("Notify context is null.");
                if (_notify_method == NULL)
                    throw std::runtime_error("Notify method is null.");
                (*_notify_context.*_notify_method)(notification);
            }

            virtual bool compareNotifyContext(void const* object) const
            {
                return _notify_context == object;
            }

            Observer& operator=(Observer const& arg)
            {
                _notify_method = arg._notify_method;
                _notify_context = arg._notify_context;
                _removed = arg._removed;
                return *this;
            }

            virtual ~Observer(void)
            { }
        private:
            _Method _notify_method;
            _Context* _notify_context;
            bool _removed;
        };

        template<typename _Method, typename _Context>
        IObserver* makeObserver(_Method notify_method, _Context* notify_context)
        {
            return new Observer<_Method, _Context>(notify_method, notify_context);
        }
    }
}

#pragma pack(pop)

#endif /* __PUREMVC_PATTERNS_OBSERVER_OBSERVER_HPP__ */