ObserverSubject_NumberProducer.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __OBSERVERSUBJECT_NUMBERPRODUCER_H__
#define __OBSERVERSUBJECT_NUMBERPRODUCER_H__
 
#include <algorithm>
#include <memory>
#include <stdint.h>
#include <vector>
 
namespace DesignPatternExamples_cpp
{
 
    struct IObserverNumberChanged
    {
        using shared_ptr_t = std::shared_ptr<IObserverNumberChanged>;
 
        virtual ~IObserverNumberChanged() {}
 
        virtual void NumberChanged() = 0;
    };
 
 
    //########################################################################
    //########################################################################
 
 
    struct IEventNotifications
    {
        virtual ~IEventNotifications() {}
 
        virtual void SubscribeToNumberChanged(IObserverNumberChanged::shared_ptr_t observer) = 0;
        virtual void UnsubscribeFromNumberChanged(IObserverNumberChanged::shared_ptr_t observer) = 0;
    };
 
 
    //########################################################################
    //########################################################################
 
 
    struct INumberProducer
    {
        using shared_ptr_t = std::shared_ptr<INumberProducer>;
 
        virtual ~INumberProducer() {}
 
        virtual void Update() = 0;
 
        virtual uint32_t FetchNumber() = 0;
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class ObserverSubject_NumberProducer : public IEventNotifications, public INumberProducer
    {
    private:
        
        using ObserversList = std::vector<IObserverNumberChanged::shared_ptr_t>;
 
        ObserversList _observers;
 
        uint32_t _number;
 
 
    private:
        void _NotifyNumberChanged()
        {
            // Copy the list so observers can change the original observers
            // during the notification (this isn't strictly needed in this
            // example but it is good practice for any notification system
            // that handles multiple observers where multiple threads might
            // be in play or observers can unsubscribe at any time, even in
            // the event notification).
            ObserversList observers = _observers;
 
            for(IObserverNumberChanged::shared_ptr_t observer : observers)
            {
                observer->NumberChanged();
            }
        }
 
        ObserversList::iterator _FindObserver(const IObserverNumberChanged::shared_ptr_t& observer)
        {
            ObserversList::iterator foundIter;
            return std::find(std::begin(_observers), std::end(_observers), observer);
        }
 
 
        bool _ContainsObserver(const IObserverNumberChanged::shared_ptr_t& observer)
        {
            ObserversList::iterator foundIter;
            foundIter = _FindObserver(observer);
            return foundIter != std::end(_observers);
        }
 
    public:
        ObserverSubject_NumberProducer()
            : _number(0)
        {
        }
 
 
        void Update() override
        {
            ++_number;
            _NotifyNumberChanged();
        }
 
 
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Implementation of the INumberProducer interface.
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        uint32_t FetchNumber() override
        {
            return _number;
        }
 
 
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Implementation of the IEventNotifications interface.
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        void SubscribeToNumberChanged(IObserverNumberChanged::shared_ptr_t observer)
        {
            if (!_ContainsObserver(observer))
            {
                _observers.push_back(observer);
            }
        }
 
 
        void UnsubscribeFromNumberChanged(IObserverNumberChanged::shared_ptr_t observer)
        {
            ObserversList::iterator foundIter;
            foundIter = _FindObserver(observer);
            if (foundIter != std::end(_observers))
            {
                _observers.erase(foundIter);
            }
        }
    };
 
} // end namespace
 
 
#endif // __OBSERVERSUBJECT_NUMBERPRODUCER_H__