include/PureMVC/Patterns/Facade/Facade.hpp

Go to the documentation of this file.

//  Facade.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_FACADE_FACADE_HPP__)
#define __PUREMVC_PATTERNS_FACADE_FACADE_HPP__

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

#include "../../Interfaces/IFacade.hpp"
#include "../../Interfaces/ICommand.hpp"
#include "../../Interfaces/IModel.hpp"
#include "../../Interfaces/IView.hpp"
#include "../../Interfaces/IController.hpp"
#include "../../Interfaces/IMediator.hpp"
#include "../../Interfaces/IAggregate.hpp"
#include "../../Interfaces/IProxy.hpp"
#include "../../Patterns/Observer/Notifier.hpp"

namespace PureMVC
{
    namespace Patterns
    {
        using Interfaces::IFacade;
        using Interfaces::ICommand;
        using Interfaces::IModel;
        using Interfaces::IView;
        using Interfaces::IController;
        using Interfaces::IMediator;
        using Interfaces::IProxy;
        using Interfaces::IAggregate;
        using Patterns::Notifier;

        class PUREMVC_API Facade : public virtual IFacade, public Notifier
        {
        public:
            typedef std::auto_ptr<IAggregate<std::string> > CoreNames;
        public:
            static char const* const DEFAULT_KEY;
        private:
            Facade(Facade const&);
            Facade(IFacade const&);
            Facade& operator=(Facade const&);
            Facade& operator=(IFacade const&);
        protected:
            static IFacade* find(std::string const& key);
            static void insert(std::string const& key, IFacade* facade);
        public:
            explicit Facade(std::string const& key = Facade::DEFAULT_KEY);

        protected:
            template<typename _DerivedType>
            explicit Facade(_DerivedType* instance, std::string const& key = Facade::DEFAULT_KEY)
            :_controller(NULL)
            ,_model(NULL)
            ,_view(NULL)
            {
                if (find(key))
                    throw std::runtime_error(MULTITON_MSG);
                instance->_DerivedType::initializeNotifier(key);
                insert(key, this);
                instance->_DerivedType::initializeFacade();
            }

            virtual void initializeFacade(void);

        public:
            static IFacade& getInstance(std::string const& key = Facade::DEFAULT_KEY);

        protected:
            virtual void initializeController(void);

            virtual void initializeModel(void);

            virtual void initializeView(void);

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

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

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

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

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

            virtual void registerProxy (IProxy* proxy);

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

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

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

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

            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 void sendNotification(std::string const& notification_name, void const* body = NULL, std::string const& type = "");

            virtual void notifyObservers(INotification const& notification);

            static bool hasCore(std::string const& key);

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

            static CoreNames listCores(void);

            virtual ~Facade(void);

        protected:
            // References to Model, View and Controller
            IController* _controller;
            IModel* _model;
            IView* _view;
            // Message Constants
            static char const* const MULTITON_MSG;
        };
    }
}

#endif /* __PUREMVC_PATTERNS_FACADE_FACADE_HPP__ */