HandlerChain_Class.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __HANDLERCHAIN_CLASS_H__
#define __HANDLERCHAIN_CLASS_H__
 
#include <algorithm>
#include <list>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
 
#include "helpers/formatstring.h"
 
namespace DesignPatternExamples_cpp
{
    struct Message; // forward declaration
 
    struct IMessageHandler
    {
        using shared_ptr_t = std::shared_ptr<IMessageHandler>;
 
        virtual ~IMessageHandler() { }
 
        virtual int ID() = 0;
 
        virtual bool ProcessMessage(Message* message) = 0;
 
        virtual std::string ToString() = 0;
    };
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    class HandlerChain
    {
    public:
        using unique_ptr_t = std::unique_ptr<HandlerChain>;
 
    private:
        std::list<IMessageHandler::shared_ptr_t> _messageHandlers;
 
        std::mutex _messageHandlersLock;
 
    public:
        void SendMessage(Message* message)
        {
            // We make a copy of the handlers so our processing of handlers
            // is not impacted by updates to the master handler list.
            std::list<IMessageHandler::shared_ptr_t> copyof_MessageHandlers(_messageHandlers.size());
            {
                std::lock_guard<std::mutex> guard(_messageHandlersLock);
                std::copy(std::begin(_messageHandlers), std::end(_messageHandlers), std::begin(copyof_MessageHandlers));
            }
 
            for(IMessageHandler::shared_ptr_t& window : copyof_MessageHandlers)
            {
                if (window->ProcessMessage(message))
                {
                    break;
                }
            }
        }
 
 
        void AddHandler(IMessageHandler::shared_ptr_t window)
        {
            std::lock_guard<std::mutex> guard(_messageHandlersLock);
            // Add the handler if not already in the list.
            std::list<IMessageHandler::shared_ptr_t>::iterator foundIter;
            foundIter = std::find_if(std::begin(_messageHandlers),
                std::end(_messageHandlers),
                [window](IMessageHandler::shared_ptr_t w) { return w->ID() == window->ID(); });
 
            if (foundIter == std::end(_messageHandlers))
            {
                _messageHandlers.push_back(window);
            }
        }
 
 
        void RemoveHandler(IMessageHandler::shared_ptr_t window)
        {
            std::lock_guard<std::mutex> guard(_messageHandlersLock);
            _messageHandlers.remove_if([window](IMessageHandler::shared_ptr_t w) { return w->ID() == window->ID(); });
        }
 
        void RemoveHandler(IMessageHandler* window)
        {
            std::lock_guard<std::mutex> guard(_messageHandlersLock);
            _messageHandlers.remove_if([window](IMessageHandler::shared_ptr_t w) { return w->ID() == window->ID(); });
        }
 
 
        std::string ToString()
        {
            std::ostringstream output;
 
            std::list<IMessageHandler::shared_ptr_t> copyof_MessageHandlers(_messageHandlers.size());
            {
                std::lock_guard<std::mutex> guard(_messageHandlersLock);
                std::copy(std::begin(_messageHandlers), std::end(_messageHandlers), std::begin(copyof_MessageHandlers));
            }
 
            for(IMessageHandler::shared_ptr_t& window : copyof_MessageHandlers)
            {
                output << Helpers::formatstring("    %s", window->ToString().c_str()) << std::endl;
            }
            return output.str();
        }
    };
 
} // end namespace
 
#endif // __HANDLERCHAIN_CLASS_H__