/Users/schell/Code/PureMVC-Plus-Plus/src/pmvcpp.h

/* 
 * File:   pmvcpp.h
 * Author: Schell Scivally - http://civiliansoftware.com
 *
 * Created on December 17, 2009, 12:56 PM
 * PureMVC++ - Copyright(c) 2009 Schell Scivally Enterprise, some rights reserved.
 * Your reuse is governed by the Creative Commons Attribution 3.0 United States License
 * 
 */

#ifndef _PMVCPP_H
#define _PMVCPP_H

#include<string>
#include<vector>
#include<map>
#include<iostream>
#include<cstdlib>
#include<stdint.h>

namespace PureMVC {


    class Object
    {
    public:
            virtual void function(){}
    };

    template <class T>
    class Multiton
    {
    public:
        static T* instance()
        {
            std::string key = "key";
            return Multiton<T>::instance(key);
        }
        static T* instance(std::string key)
        {
            if(Multiton<T>::exists(key))
                return Multiton<T>::instanceMap[key];

            T* inst = new T();

            Multiton<T>::instanceMap[key] = inst;
            return inst;
        }
        static bool exists(std::string key)
        {
            return Multiton<T>::instanceMap.find(key) != Multiton<T>::instanceMap.end();
        }
        static size_t size()
        {
            return Multiton<T>::instanceMap.size();
        }
        static void erase(std::string key)
        {
            Multiton<T>::instanceMap.erase(key);
        }
        static void clear()
        {
            Multiton<T>::instanceMap.clear();
        }
    private:
        Multiton();
        ~Multiton();
        Multiton(Multiton const&); // copy constructor
        Multiton& operator=(Multiton const&);
        static std::map<std::string, T*> instanceMap;
    };
    // define
    template <class T>
    std::map<std::string, T*> Multiton<T>::instanceMap;
    //--------------------------------------
    //  IMultitonKeyHeir
    //--------------------------------------
    class IMultitonKeyHeir
    {
    public:
        virtual void setMultitonKey(std::string key) = 0;
        virtual std::string getMultitonKey() = 0;
    };
    //--------------------------------------
    //  INotifier
    //--------------------------------------
    class INotifier
    {
    public:
        virtual void sendNotification   ( int notificationName, Object* body, int notificationType) = 0;
        virtual void sendNotification   ( int notificationName, int notificationType ) = 0;
        virtual void sendNotification   ( int notificationName, Object* body ) = 0;
        virtual void sendNotification   ( int notificationName ) = 0;
        virtual void initializeNotifier ( std::string key ) = 0;
        virtual          ~INotifier         (){};
    };
    class INotification
    {
    public:
            virtual int getName () = 0;
            virtual void setBody( Object* body ) = 0;
            virtual Object* getBody() = 0;
            virtual void setType( int notificationType ) = 0;
            virtual int getType() = 0;
            virtual ~INotification(){};
    };
    class ICommand : public virtual INotifier
    {
    public:
            virtual void execute( INotification* notification ) = 0;
            virtual      ~ICommand      (){};
    };
    class IController : public virtual IMultitonKeyHeir
    {
    public:
        IController(){}
            //virtual void registerCommand( int notificationName, ICommand* commandClassRef )
            //virtual void executeCommand( INotification* notification ) = 0;
            virtual void removeCommand( int notificationName ) = 0;
            virtual bool hasCommand( int notificationName ) = 0;
            virtual ~IController(){};
    };
    class INotificationHandler
    {
    public:
        virtual void handleNotification ( INotification* notification ) = 0;
    };
    class IObserverRestricted
    {
    public:
        virtual void notifyObserver(INotification* notification) = 0;
        virtual bool compareNotifyContext( intptr_t memoryAddress ) = 0;
    };
    template<class T>
    class IObserverTemplated : public IObserverRestricted
    {
    public:
            virtual void setNotifyMethod( void(T::*fptr)(INotification*) ) = 0;
            virtual void setNotifyContext( T* notifyContext ) = 0;

            virtual ~IObserverTemplated(){};
    };
    class IProxyRestricted : public virtual INotifier
    {
    public:
            virtual std::string getProxyName() = 0;
            virtual void onRegister() = 0;
            virtual void onRemove() = 0;
    };
    template<class T>
    class IProxyTemplated : public IProxyRestricted
    {
    public:
            virtual void setData( T data ) = 0;
            virtual T getData() = 0;
    };
    class IModel : public virtual IMultitonKeyHeir
    {
    public:
            virtual void registerProxy( IProxyRestricted* proxy ) = 0;
            virtual IProxyRestricted* retrieveProxy( std::string proxyName ) = 0;
            virtual IProxyRestricted* removeProxy( std::string proxyName ) = 0;
            virtual bool hasProxy( std::string proxyName ) = 0;
            virtual ~IModel(){};
    };

    class IMediatorRestricted : public virtual INotifier, public INotificationHandler
    {
    public:
            virtual std::string getMediatorName() = 0;
            virtual std::vector<int> listNotificationInterests() = 0;
            virtual void onRegister() = 0;
            virtual void onRemove() = 0;

            virtual ~IMediatorRestricted(){};
    };
    template<class T>
    class IMediatorTemplated : public IMediatorRestricted
    {
    public:
            virtual T getViewComponent() = 0;
            virtual void setViewComponent( T viewComponent ) = 0;

            virtual ~IMediatorTemplated(){};

    };
    class IView : public virtual IMultitonKeyHeir
    {
    public:
            virtual void registerObserver( int notificationName, IObserverRestricted* observer ) = 0;
            virtual void removeObserver( int notificationName, intptr_t contextAddress ) = 0;
            virtual void notifyObservers( INotification* note ) = 0;
            virtual void registerMediator( IMediatorRestricted* mediator ) = 0;
            virtual IMediatorRestricted* retrieveMediator( std::string mediatorName ) = 0;
            virtual IMediatorRestricted* removeMediator( std::string mediatorName ) = 0;
            virtual bool hasMediator( std::string mediatorName ) = 0;
            virtual ~IView(){};
    };
    class IFacade : public INotifier, public virtual IMultitonKeyHeir
    {
    public:
            virtual void registerProxy( IProxyRestricted* proxy ) = 0;
            virtual IProxyRestricted* retrieveProxy( std::string proxyName ) = 0;
            virtual IProxyRestricted* removeProxy( std::string proxyName ) = 0;
            virtual bool hasProxy( std::string proxyName ) = 0;
            //void                    registerCommand   ( std::string noteName, ICommand* commandClassRef );
            virtual void removeCommand( int notificationName ) = 0;
            virtual bool hasCommand( int notificationName ) = 0;
            virtual void registerMediator( IMediatorRestricted* mediator ) = 0;
            virtual IMediatorRestricted* retrieveMediator( std::string mediatorName ) = 0;
            virtual IMediatorRestricted* removeMediator( std::string mediatorName ) = 0;
            virtual bool hasMediator( std::string mediatorName ) = 0;
            virtual void notifyObservers( INotification* notification ) = 0;
    };

    //--------------------------------------
    //  MultitonKeyHeir
    //--------------------------------------
    class MultitonKeyHeir : public virtual IMultitonKeyHeir
    {
    public:
        virtual void setMultitonKey(std::string key);
        virtual std::string getMultitonKey();
    private:
        std::string _multitonKey;
    };
    //--------------------------------------
    //  Notification
    //--------------------------------------
    class Notification : public INotification
    {
    public:
        int name;
        int type;
        Object* body;
        Notification(int notificationName, Object* body, int notificationType);
        Notification(int notificationName, Object* body);
        Notification(int notificationName, int notificationType);
        Notification(int notificationName);
        int getName();
        void setBody( Object* body );
        Object* getBody();
        void setType( int notificationType );
        int getType();
    };
    //--------------------------------------
    //  Notifier
    //--------------------------------------
    class Notifier : public MultitonKeyHeir, public virtual INotifier
    {
    public:
        void sendNotification   ( int notificationName, Object* body, int notificationType);
        void sendNotification   ( int notificationName, int notificationType );
        void sendNotification   ( int notificationName, Object* body );
        void sendNotification   ( int notificationName );
        void initializeNotifier(std::string key);

    protected:
        IFacade* getFacade();
    };
    //--------------------------------------
    //  SimpleCommand
    //--------------------------------------
    class SimpleCommand : public Notifier, public ICommand
    {
    public:
        virtual void execute(INotification* notification) = 0;
    };
    //--------------------------------------
    //  MacroCommand
    //--------------------------------------

    class MacroCommand : public SimpleCommand
    {
    public:
        MacroCommand();
        void execute(INotification* notification);
    protected:
        void addSubCommand( ICommand* command );
        std::vector<ICommand*> subCommands;
    };
    template<class T>
    class Observer : public IObserverTemplated<T>
    {
    private:
        typedef void(T::*NotifyMethod)(INotification*);
        typedef T* NotifyContext;
        NotifyMethod notifyMethod;
        NotifyContext notifyContext;
    public:
        Observer( NotifyMethod method, NotifyContext context )
        {
            this->setNotifyMethod(method);
            this->setNotifyContext(context);
        }
        void setNotifyMethod( NotifyMethod method )
        {
            this->notifyMethod = method;
        }
        void setNotifyContext( NotifyContext context )
        {
            this->notifyContext = context;
        }
        NotifyMethod getNotifyMethod()
        {
            return this->notifyMethod;
        }
        NotifyContext getNotifyContext()
        {
            return this->notifyContext;
        }
        void notifyObserver( INotification* notification )
        {
            (this->notifyContext->*notifyMethod)(notification);
        }
        bool compareNotifyContext( intptr_t compareContextMemoryAddress )
        {
            return compareContextMemoryAddress == (intptr_t) &*this->getNotifyContext();
        }
    };
    //--------------------------------------
    //  Proxy
    //--------------------------------------
    template<class T>
    class Proxy : public IProxyTemplated<T>, public Notifier
    {
    public:
        Proxy()
        {
        }
        Proxy(std::string proxyName, T data)
        {
            this->proxyName = proxyName;
            this->data = data;
        }
        Proxy(std::string proxyName)
        {
            this->proxyName = proxyName;
        }
        Proxy(T data)
        {
            this->data = data;
        }
        std::string getProxyName()
        {
            return this->proxyName;
        }

        void setData( T data )
        {
            this->data = data;
        }

        T getData()
        {
            return this->data;
        }

        static std::string NAME;

    protected:
        // the proxy name
        std::string proxyName;

        // the data object
        T data;
    };
    //--------------------------------------
    //  Mediator
    //--------------------------------------
    template<class T>
    class Mediator : public IMediatorTemplated<T>, public Notifier
    {
    public:
        Mediator( std::string mediatorName, T viewComponent )
        {
            this->mediatorName = mediatorName;
            this->setViewComponent(viewComponent);
        }
        Mediator( std::string mediatorName )
        {
            this->mediatorName = mediatorName;
        }
        Mediator( T viewComponent )
        {
            this->setViewComponent(viewComponent);
        }
        std::string getMediatorName()
        {
            return this->mediatorName;
        }

        void setViewComponent( T viewComponent )
        {
            this->viewComponent = viewComponent;
        }

        T getViewComponent()
        {
            return this->viewComponent;
        }

        virtual std::vector<int> listNotificationInterests() = 0;

        virtual void handleNotification( INotification* notification ) = 0;

        virtual void onRegister() = 0;

        virtual void onRemove() = 0;

        std::string getName()
        {
            return this->mediatorName;
        }

        static const std::string NAME;

    protected:
        // the mediator name
        std::string mediatorName;

        // The view component
        T viewComponent;
    };
    template<class T>
    const typename std::string Mediator<T>::NAME = "Mediator";
    //--------------------------------------
    //  Model
    //--------------------------------------
    class Model : public MultitonKeyHeir, public IModel
    {
    public:
        Model();

        static IModel* getInstance(std::string key);
        void registerProxy( IProxyRestricted* proxy );
        IProxyRestricted* retrieveProxy( std::string proxyName );

        bool hasProxy( std::string proxyName );

        IProxyRestricted* removeProxy( std::string proxyName );

        static void removeModel( std::string key );

    protected:
        // Mapping of proxyNames to IProxy instances
        std::map <std::string, IProxyRestricted*> proxyMap;
    };

    //--------------------------------------
    //  View
    //--------------------------------------
    class View : public MultitonKeyHeir, public IView
    {
    public:
        View( );
        static IView* getInstance( std::string key );
        void registerObserver ( int notificationName, IObserverRestricted* observer );
        void notifyObservers( INotification* notification );

        void removeObserver( int notificationName, intptr_t contextAddress );

        void registerMediator( IMediatorRestricted* mediator );

        IMediatorRestricted* retrieveMediator( std::string mediatorName );

        IMediatorRestricted* removeMediator( std::string mediatorName );

        bool hasMediator( std::string mediatorName );

        static void removeView( std::string key );

    protected:
        // Mapping of Mediator names to Mediator instances
        std::map<std::string, IMediatorRestricted*> mediatorMap;

        // Mapping of Notification names to Observer lists
        std::map<int, std::vector<IObserverRestricted*> > observerMap;

    private:
        bool existsObserversInterestedIn(int notificationName);
    };

    //--------------------------------------
    //  Controller
    //--------------------------------------
    class Controller : public MultitonKeyHeir, public IController
    {
    public:
        Controller();
        static IController* getInstance( std::string key );
        template<class T>
        void executeCommand( INotification* note )
        {
            // this is a special to c++ function,
            // i feel like we're cheating here, but
            // it's nice, but we had to get rid of
            // executeCommand and registerCommand
            // from IController for it... ...if you
            // can think of a better way to keep this
            // commands stateless through this execution
            // then be my guest to revise this. - Schell
            int name = note->getName();
            // if this command isn't listed, abort
            if(! this->hasCommand(name))
                return;
            // make a new instance of the command
            ICommand* command = new T();
            command->initializeNotifier(this->getMultitonKey());
            command->execute(note);
            // get rid of the evidence
            delete command;
        };
        //void registerCommand( int notificationName, ICommand* commandClassRef );
        template<class T>
        void registerCommand(int notificationName)
        {
            // if we've already registered a command for this notification
            // abort
            if(this->hasCommand(notificationName))
                return;
            // create an observer for this command
            Observer<Controller>* observer = new Observer<Controller>(&Controller::executeCommand<T>, this);
            // register the observer with the view
            this->view->registerObserver(notificationName, observer);
            // give the commanMap something to chew on
            commandMap[notificationName] = (T*) 0;
        };
        bool hasCommand( int notificationName );

        void removeCommand( int notificationName );

        static void removeController( std::string key );

    protected:
        void initializeController();

        // Local reference to View
        IView* view;

        // Mapping of Notification names to Command Class references
        std::map<int, ICommand*> commandMap;
    };
    //--------------------------------------
    //  Facade
    //--------------------------------------
    class Facade : public IFacade, public MultitonKeyHeir
    {
    public:
        Facade();
        static Facade* getInstance(std::string);
        template<class T>
        void registerCommand( int notificationName )
        {
            dynamic_cast<Controller*>(this->controller)->registerCommand<T>(notificationName);
        };

        void removeCommand( int notificationName );

        bool hasCommand( int notificationName );

        void registerProxy ( IProxyRestricted* proxy );
        IProxyRestricted* retrieveProxy ( std::string proxyName );

        IProxyRestricted* removeProxy ( std::string proxyName );

        bool hasProxy( std::string proxyName );

        void registerMediator( IMediatorRestricted* mediator );

        IMediatorRestricted* retrieveMediator( std::string mediatorName );

        IMediatorRestricted* removeMediator( std::string mediatorName );

        bool hasMediator( std::string mediatorName );

        void sendNotification( int notificationName, Object* body, int notificationType );
        void sendNotification( int notificationName, Object* body );
        void sendNotification( int notificationName, int notificationType );
        void sendNotification( int notificationName );
        void notifyObservers ( INotification* notification );

        void initializeNotifier( std::string key );

        static bool hasCore( std::string key );

        static void removeCore( std::string key );
    protected:
        void initializeFacade();

        void initializeController( );

        void initializeModel( );


        void initializeView( );


        // References to Model, View and Controller
        IController* controller;
        IModel* model;
        IView* view;
    };

}

#endif  /* _PMVCPP_H */

---