include/PureMVC/Core/Controller.hpp

Go to the documentation of this file.

//  Controller.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_CONTROLLER_HPP__)
#define __PUREMVC_CORE_CONTROLLER_HPP__

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

#include "../Interfaces/IModel.hpp"
#include "../Interfaces/ICommand.hpp"
#include "../Interfaces/IObserver.hpp"
#include "../Patterns/Iterator/Iterator.hpp"

namespace PureMVC
{
    namespace Core
    {
        using Interfaces::IModel;
        using Interfaces::IController;
        using Interfaces::ICommand;
        using Interfaces::IObserver;
        using Interfaces::IAggregate;
        using Interfaces::IIterator;

        class PUREMVC_API Controller : public virtual IController
        {
        protected:
            typedef std::map<std::string, ICommand*> CommandMap;
        protected:
            /*
             * Define iterator converter for getting notification name only.
             */
            struct IteratorConverter
#if !defined(__DMC__) // The C++ compiler of Digital Mars cannot resolve this case
            : public std::unary_function<CommandMap::const_iterator, CommandMap::key_type>
#endif
            {
                /*
                 * Converting operator.
                 *
                 * @param iterator the iterator of internal container.
                 * @return the name of notification inside iterator.
                 */
                CommandMap::key_type const& operator()(CommandMap::const_iterator const& iterator) const;
            };
            /*
             * Define iterator range of internal container.
             */
            struct IteratorRange {
                /*
                 * Get begin point.
                 *
                 * @return the begin of iterator.
                 */
                CommandMap::const_iterator begin(CommandMap const* const& iterator) const;
                /*
                 * Get end point.
                 *
                 * @return the end of iterator.
                 */
                CommandMap::const_iterator end(CommandMap const* const& iterator) const;
            };
        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;
            // Local reference to View
            IView* _view;
            // Mapping of Notification names to Command Class references
            CommandMap _command_map;
            // Synchronous access
            mutable Mutex _synchronous_access;
        private:
            Controller(Controller const&);
            Controller(IController const&);
            Controller& operator=(Controller const&);
            Controller& operator=(IController const&);
        protected:
            static IController* find(std::string const& key);
            static void insert(std::string const& key, IController* controller);
        public:
            explicit Controller(std::string const& key = Controller::DEFAULT_KEY);

        protected:
            // Support call virtual method in constructor of base class (Controller).
            // Condition: Derived class (class inherit from Controller) must implement
            // method: initializeController
            template<typename _DerivedType>
            explicit Controller(_DerivedType* instance, std::string const& key = Controller::DEFAULT_KEY)
            :_multiton_key(key)
            ,_view(NULL)
            {
                if (find(_multiton_key))
                    throw std::runtime_error(MULTITON_MSG);
                insert(_multiton_key, this);
                instance->_DerivedType::initializeController();
            }

            virtual void initializeController(void);

        public:
            static IController& getInstance(std::string const& key = Controller::DEFAULT_KEY);

            virtual void executeCommand(INotification const& notification);

            virtual void registerCommand(std::string const& notification_name, ICommand* command);

            virtual bool hasCommand(std::string const& notification_name) const;

            virtual ICommand const& retrieveCommand(std::string const& notification_name) const;

            virtual ICommand& retrieveCommand(std::string const& notification_name);

            virtual ICommand* removeCommand(std::string const& notification_name);

            virtual NotificationNames listNotificationNames(void) const;

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

            virtual ~Controller(void);
        };
    }
}

#endif /* __PUREMVC_CORE_CONTROLLER_HPP__ */