include/PureMVC/Core/Model.hpp

Go to the documentation of this file.

//  Model.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_MODEL_HPP__)
#define __PUREMVC_CORE_MODEL_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/IProxy.hpp"
#include "../Patterns/Iterator/Iterator.hpp"

namespace PureMVC
{
    namespace Core
    {
        using Interfaces::IModel;
        using Interfaces::IProxy;
        using Interfaces::IAggregate;
        using Interfaces::IIterator;

        class PUREMVC_API Model : public virtual IModel
        {
        protected:
            typedef std::map<std::string, IProxy*> ProxyMap;
        protected:
            /*
             * Define iterator converter for getting proxy name only.
             */
            struct IteratorConverter
#if !defined(__DMC__) // The C++ compiler of Digital Mars cannot resolve this case
                : public std::unary_function<ProxyMap::const_iterator, ProxyMap::key_type> 
#endif          
            {
                /*
                 * Converting operator.
                 *
                 * @param iterator the iterator of internal container.
                 * @return the name of proxy inside iterator.
                 */
                ProxyMap::key_type const& operator()(ProxyMap::const_iterator const& iterator) const;
            };
            /*
             * Define iterator range of internal container.
             */
            struct IteratorRange {
                /*
                 * Get begin point.
                 *
                 * @return the begin of iterator.
                 */
                ProxyMap::const_iterator begin(ProxyMap const* const& iterator) const;
                /*
                 * Get end point.
                 *
                 * @return the end of iterator.
                 */
                ProxyMap::const_iterator end(ProxyMap const* const& iterator) const;
            };
        public:
            static char const* const DEFAULT_KEY;
        protected:
            // Message Constants
            static char const* const MULTITON_MSG;
            // The Multiton Key for this Core
            std::string const _multiton_key;
            // Mapping of proxyNames to IProxy instances
            ProxyMap _proxy_map;
            // Synchronous access
            mutable Mutex _synchronous_access;
        private:
            Model(Model const&);
            Model(IModel const&);
            Model& operator=(Model const&);
            Model& operator=(IModel const&);
        protected:
            static IModel* find(std::string const& key);
            static void insert(std::string const& key, IModel* model);
        public:
            explicit Model(std::string const& key = PureMVC::Core::Model::DEFAULT_KEY);

        protected:
            template<typename _DerivedType>
            explicit Model(_DerivedType* instance, std::string const& key = PureMVC::Core::Model::DEFAULT_KEY)
            :_multiton_key(key)
            {
                if (find(key))
                    throw std::runtime_error(MULTITON_MSG);
                insert(_multiton_key, this);
                instance->_DerivedType::initializeModel();
            }

            virtual void initializeModel(void);

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

            virtual void registerProxy(IProxy* proxy);

            virtual IProxy const& retrieveProxy(std::string const& proxy_name) const;

            virtual IProxy& retrieveProxy(std::string const& proxy_name);

            virtual bool hasProxy(std::string const& proxy_name) const;

            virtual IProxy* removeProxy(std::string const& proxy_name);

            virtual ProxyNames listProxyNames(void) const;

            static void removeModel(std::string const& key);
            
            virtual ~Model(void);
        };
    }
}

#endif /* __PUREMVC_CORE_MODEL_HPP__ */