include/PureMVC/Core/View.hpp

Go to the documentation of this file.

//  View.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_CORE_VIEW_HPP__)
#define __PUREMVC_CORE_VIEW_HPP__

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

#include "../Interfaces/IView.hpp"
#include "../Interfaces/IObserver.hpp"
#include "../Interfaces/INotification.hpp"
#include "../Interfaces/IMediator.hpp"
#include "../Interfaces/IAggregate.hpp"
#include "../Interfaces/IIterator.hpp"
#include "../Patterns/Iterator/Iterator.hpp"

namespace PureMVC
{
    namespace Core
    {
        using Interfaces::IObserver;
        using Interfaces::IView;
        using Interfaces::INotification;
        using Interfaces::IMediator;
        using Interfaces::IAggregate;
        using Interfaces::IIterator;

        class PUREMVC_API View : public virtual IView
        {
        protected:
            typedef std::map<std::string, IMediator*> MediatorMap;
            typedef std::multimap<std::string, IObserver*> ObserverMap;
        protected:
            /*
             * Define iterator converter for getting mediator name only.
             */
            struct IteratorConverter
#if !defined(__DMC__) // The C++ compiler of Digital Mars cannot resolve this case
            : public std::unary_function<MediatorMap::const_iterator, MediatorMap::key_type>
#endif
            {
            /*
             * Converting operator.
             *
             * @param iterator the iterator of internal container.
             * @return the name of mediator inside iterator.
             */
                MediatorMap::key_type const& operator()(MediatorMap::const_iterator const& iterator) const;
            };
            /*
             * Define iterator range of internal container.
             */
            struct IteratorRange {
                /*
                 * Get begin point.
                 *
                 * @return the begin of iterator.
                 */
                MediatorMap::const_iterator begin(MediatorMap const* const& iterator) const;
                /*
                 * Get end point.
                 *
                 * @return the end of iterator.
                 */
                MediatorMap::const_iterator end(MediatorMap const* const& iterator) const;
            };
        protected:
            struct IPassiveObserver {
                virtual ~IPassiveObserver(void);
            };
            class RemovingObserver : public IPassiveObserver {
            private:
                ObserverMap::iterator _item;
            public:
                explicit RemovingObserver(ObserverMap::iterator const& item);
                ObserverMap::iterator const& operator()(void) const;
            private:
                RemovingObserver(RemovingObserver const&);
                RemovingObserver& operator=(RemovingObserver const&);
            public:
                virtual ~RemovingObserver(void);
            };
            class InsertedObserver : public IPassiveObserver {
            private:
                ObserverMap::value_type _item;
            public:
                explicit InsertedObserver(ObserverMap::value_type const& item);
                ObserverMap::value_type const& operator()(void) const;
            private:
                InsertedObserver(InsertedObserver const&);
                InsertedObserver& operator=(InsertedObserver const&);
            public:
                virtual ~InsertedObserver(void);
            };
        public:
            static char const* const DEFAULT_KEY;
        protected:
            // Message Constants
            static char const* const MULTITON_MSG;
        protected:
            // The Multiton Key for this Core
            std::string const _multiton_key;
            // Mapping of Mediator names to Mediator instances
            MediatorMap _mediator_map;
            // Mapping of Notification names to Observer lists
            ObserverMap _observer_map;
            // In loop flag
            int _inloop_counter;
            typedef std::list<IPassiveObserver*> PassiveObserverList;
            // Being remove observer
            PassiveObserverList _passive_observer_list;
            // Synchronous access
            mutable Mutex _synchronous_access;
        private:
            View(View const&);
            View(IView const&);
            View& operator=(View const&);
            View& operator=(IView const&);
        protected:
            static IView* find(std::string const& key);
            static void insert(std::string const& key, IView* view);
        public:
            explicit View(std::string const& key = PureMVC::Core::View::DEFAULT_KEY);
        protected:
            template<typename _DerivedType>
            explicit View(_DerivedType* instance, std::string const& key = PureMVC::Core::View::DEFAULT_KEY)
            :_multiton_key(key)
            {
                if (find(key))
                    throw std::runtime_error(MULTITON_MSG);
                insert(_multiton_key, this);
                instance->_DerivedType::initializeView();
            }

            virtual void initializeView(void);

        public:
            static IView& getInstance(std::string const& key = PureMVC::Core::View::DEFAULT_KEY);

            virtual void registerObserver (std::string const& notification_name, IObserver* observer);

            virtual void notifyObservers(INotification const& notification);

            virtual void removeObserver(std::string const& notification_name, IObserver const* notify_context);

            virtual void registerMediator(IMediator* mediator);

            virtual IMediator const& retrieveMediator(std::string const& mediator_name) const;

            virtual IMediator& retrieveMediator(std::string const& mediator_name);

            virtual IMediator* removeMediator(std::string const& mediator_name);

            virtual bool hasMediator(std::string const& mediator_name) const;

            virtual MediatorNames listMediatorNames(void) const;

            static void removeView(std::string const& key);

            virtual ~View(void);

            void joinAllPassiveObserver(void);
        };
    }
}

#endif /* __PUREMVC_CORE_VIEW_HPP__ */