Observer.h

Go to the documentation of this file.

#ifndef __OBSERVER_H__
#define __OBSERVER_H__


#include <Base/Timer.h>


#include <assert.h>

#include <iostream>
#include <list>
#include <set>
#include <vector>

namespace Base
{
template <class _MessageType>
class Subject;

template <class _MessageType>
class Observer
{
public:
    Observer()
        : _observerPriority(1)  // default priority
        {

        };

    virtual ~Observer()
    {
        cDebug("~Observer %s %x", this->name() ? this->name() : "No Name", this);
        if (!_subjects.empty())
        {
            auto copy_subjects = _subjects;
            cWarn("Observer %s %x is not detached!!!!", this->name() ? this->name() : "No Name", this);
            for (auto s : copy_subjects)
                s->detach(this);
        }
        val = 0xDEADBEEF;
    };



    virtual void onChange(Subject<_MessageType>* rCaller, _MessageType rcReason) = 0;

    virtual void onDestroy(Subject<_MessageType>& /*rCaller*/) {}

    virtual const char* name(void) { return "<no name>"; }

    void setObserverPriority(int priority) { _observerPriority = priority; }
    inline int getObserverPriority() const { return _observerPriority; }

    void setAttached(Subject<_MessageType>* t) { _subjects.push_back(t); };
    void setDetached(Subject<_MessageType>* t)
    {
        _subjects.erase( std::find( _subjects.begin(), _subjects.end(), t ));
        //_subjects.erase(std::remove(_subjects.begin(), _subjects.end(), t),_subjects.end());
    };

private:    
    long val = 0xBADEAFFE;
    std::vector<Subject<_MessageType>*> _subjects;
    int _observerPriority;
};


template <class _MessageType>
class Subject
{
public:
    typedef Observer<_MessageType> ObserverType;
    typedef _MessageType MessageType;
    typedef Subject<_MessageType> SubjectType;

    struct ObserverHolder
    {
        ObserverHolder() = default;
        ObserverHolder(ObserverType* aobserverPtr) :observerPtr(aobserverPtr),observerPriority(aobserverPtr->getObserverPriority()), isAttached(true) {  }
        ObserverType*  observerPtr;
        int            observerPriority;    
        mutable bool   isAttached;
    };

    

    Subject() : _running_notify{false} { };

    virtual ~Subject()
    {        

        if( _running_notify )
        {
            cWarn("FATAL ERROR, ~Subject %X call while running notify!" ); 
            cDebuggerBreak("FATAL ERROR ~Subject call running notify!");
        }
        
        if( _ObserverSet.size() != 0 )
        {
            cWarn("Not detached all observers yet" );
        }
    }

    void attach(Observer<_MessageType>* ToObserv)
    {
        
        ToObserv->setAttached(this);

        std::string name = ToObserv->name() ? ToObserv->name() : "No Name";
        std::ostringstream oss;
        oss << " " << ToObserv;
        name += oss.str();

        if( _running_notify )
        {
            cDebug("Subject %x, attach Observer %s %X while running notify",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
            _ObserverSet_AddedLater.insert(ObserverHolder(ToObserv));
        }

        if( _ObserverSet.find(ToObserv) == _ObserverSet.end() )
        {
            cDebug("Subject %x, attach Observer %s %X ",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
            _ObserverSet.insert(ObserverHolder(ToObserv));            
        }
        else
        {
            cWarn("Subject %x, attach Observer %s %X already attached",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
            _ObserverSet.insert(ObserverHolder(ToObserv));            
        }
    }

    void detach(Observer<_MessageType>* ToObserv)
    {      
        cDebug("DETACH 0x%X",ToObserv);
        if( _running_notify )
        {
            ObserverSetType::iterator it = _ObserverSet.find(ObserverHolder(ToObserv));            
            if( it != _ObserverSet.end() )
            {
                cWarn("**** Subject %x, detach Observer %s %X while running notify",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
                (*it).isAttached = false;
            }

            auto it2 = _ObserverSet_AddedLater.find(ObserverHolder(ToObserv));
            if( it2 != _ObserverSet_AddedLater.end() )
            {
                cWarn("**** Subject %x, detach Observer %s %X while running notify",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
                (*it2).isAttached = false;
            }

        }
        else
        {
            if (_ObserverSet.find(ToObserv) != _ObserverSet.end())
            {
                cDebug("Subject %x, detach Observer %s %X",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
                ToObserv->setDetached(this);
                _ObserverSet.erase(ToObserv);
            }
            else
            {
                cWarn("Subject %x, detach Observer %s %X not found",this, ToObserv->name() ? ToObserv->name() : "No Name", ToObserv);
            }        
        }
        
    }

    void detachAll()
    {
        auto observerSetCopy = _ObserverSet;
        for (auto observer : observerSetCopy)
        {
            if( observer.isAttached )
                observer.observerPtr->setDetached(this);
        }

        auto observerSet_AddedLater_Copy = _ObserverSet_AddedLater;
        for (auto observer : observerSet_AddedLater_Copy)
        {
            if( observer.isAttached )
                observer.observerPtr->setDetached(this);
        }

        _ObserverSet.clear();
        _ObserverSet_AddedLater.clear();
    }

    void notify_internal(_MessageType& rcReason, size_t deep)
    {
        if( deep > 10 )
        {
            cWarn("ERROR notify_internal, to deep recursion!");
            cDebuggerBreak("ERROR notify_internal, to deep recursion!");
            return;
        }

        for (auto observer : getObserverSortedByPriority(_ObserverSet) )
        {
            // Was detached, maybe in another observer.
            if( !observer.isAttached )
                continue;                

            if (Core::getLogLevel() >= Core::LOGLEVEL::D_DEBUG)
            {
                // store name here, maybe it is possible, that observer will be deleted in onChange method, so we do not want to access Iter->first after that
                std::string observerName = (observer.observerPtr)->name() ? (observer.observerPtr)->name() : "<no Name>";

                Base::Timer t;                    
                (observer.observerPtr)->onChange(this, rcReason);  // send OnChange-signal
                auto myt = t.elapsedMS();

                if (_observerTime.find(observerName) == _observerTime.end())
                    _observerTime[observerName] = myt;
                else
                    _observerTime[observerName] += myt;

                if (myt > 50)
                    cWarn("  Observer (%s) need %f ms", observerName.c_str(), t.elapsedMS());
                else if (myt > 5)
                    cDebug("  Observer (%s) need %f ms", observerName.c_str(), t.elapsedMS());
            }
            else
            {                    
                (observer.observerPtr)->onChange(this, rcReason);  // send OnChange-signal
            }

        }


        // Is a Observer attached while notify?
        int counter = 10;
        while( !_ObserverSet_AddedLater.empty() )
        {
            auto copy_ObserverSet_AddedLater = getObserverSortedByPriority(_ObserverSet_AddedLater);            
            _ObserverSet_AddedLater.clear();
            for (auto observer : copy_ObserverSet_AddedLater)
            {
                if( observer.isAttached )
                    observer.observerPtr->onChange(this, rcReason);  // send OnChange-signal                
                _ObserverSet.insert(observer);
            }            

            if( (counter--) <= 0 )
            {
                cWarn("ERROR _ObserverSet_AddedLater, to many repeats!");
                cDebuggerBreak("ERROR notify_internal, to deep recursion!");
                break; 
            }
        }

        // Now process the messages we got while running notify...
        auto copy_messages_WhileRunningNotify = _messages_WhileRunningNotify;
        _messages_WhileRunningNotify.clear();
        for(auto &message : copy_messages_WhileRunningNotify )
        {
            notify_internal( message, deep+1 );
        }
    
    }
    
    void notify(_MessageType& rcReason)
    {
        if (_running_notify)
        {
            _messages_WhileRunningNotify.push_back(rcReason);
            return;
        }
        _running_notify = true;                          
        notify_internal(rcReason, 1);
        _running_notify = false;
    }

    Observer<_MessageType>* get(const char* Name)
    {
        const char* OName;
        for (auto observer : _ObserverSet)
        {
         
            OName = observer.observerPtr->name();  // get the name
            if (OName && strcmp(OName, Name) == 0)
                return observer.observerPtr;         
        }

        return nullptr;
    }

    std::vector<Observer<_MessageType>*> getAll()
    {
        std::vector<Observer<_MessageType>*> ret;
        for (auto observer : _ObserverSet)
        {
            ret.push_back(observer.observerPtr);
        }
        return ret;
        
    }

    virtual const char* subject_name(void) { return "NO SUBJECT NAME"; }

    void resetObserverTime() { _observerTime.clear(); }

    std::map<std::string, double> getObserverTime() { return _observerTime; }


    

protected:


    // Compare observers according priority. Higher priority first.
    struct CompareObservers
    {
        bool operator()(const ObserverHolder& o1, const ObserverHolder& o2) const
        {            
            return o1.observerPtr < o2.observerPtr;            
        }
    };

        
    typedef std::set<ObserverHolder, CompareObservers> ObserverSetType;

    std::vector<ObserverHolder> getObserverSortedByPriority( const ObserverSetType& obs )
    {
        std::vector<ObserverHolder> ret( obs.begin(), obs.end() ) ;

        std::sort(ret.begin(), ret.end(), [](const ObserverHolder& a,const ObserverHolder& b)
            { return a.observerPriority < b.observerPriority; });

        return ret;        
    }

    ObserverSetType _ObserverSet;  
    ObserverSetType _ObserverSet_AddedLater;  
    bool _running_notify;    
    std::list<_MessageType> _messages_WhileRunningNotify;
    std::map<std::string, double> _observerTime;
};


}  // namespace Base


#endif  // __OBSERVER_H__