Observer.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/List.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/internal/copy_move.h>
 
#ifndef OGDF_MEMORY_POOL_NTS
#   include <mutex>
#endif
 
namespace ogdf {
 
template<typename TObserved, typename TObserver>
class Observer {
public:
    Observer() = default;
 
    virtual ~Observer() { reregister(nullptr); }
 
    OGDF_NO_COPY(Observer)
    OGDF_NO_MOVE(Observer)
 
    
    void reregister(const TObserved* obs) {
        const TObserved* old = m_pObserved;
        if (m_pObserved) {
            m_pObserved->unregisterObserver(m_itObsList);
        }
        m_pObserved = obs;
        if (m_pObserved != nullptr) {
            m_itObsList = obs->registerObserver(dynamic_cast<TObserver*>(this));
        }
        registrationChanged(old);
    }
 
    virtual void registrationChanged(const TObserved* old) { }
 
    const TObserved* getObserved() const { return m_pObserved; }
 
private:
    const TObserved* m_pObserved = nullptr; 
    typename ListPure<TObserver*>::iterator m_itObsList; 
};
 
template<typename TObserver, typename TObserved>
class Observable {
    friend Observer<TObserved, TObserver>;
 
#ifndef OGDF_MEMORY_POOL_NTS
    mutable std::mutex m_mutexRegArrays; 
#endif
    mutable ListPure<TObserver*> m_regObservers; 
 
public:
    Observable() = default;
 
    virtual ~Observable() {
        // clearObservers must be called by child class, calling it here would
        // notify Observers with an already partially destructed Observable
        OGDF_ASSERT(m_regObservers.empty());
    }
 
    OGDF_NO_COPY(Observable)
    OGDF_NO_MOVE(Observable)
 
private:
 
    typename ListPure<TObserver*>::iterator registerObserver(TObserver* obs) const {
#ifndef OGDF_MEMORY_POOL_NTS
        std::lock_guard<std::mutex> guard(m_mutexRegArrays);
#endif
        OGDF_ASSERT(obs != nullptr);
        return m_regObservers.pushBack(obs);
    }
 
 
    void unregisterObserver(typename ListPure<TObserver*>::iterator it) const {
#ifndef OGDF_MEMORY_POOL_NTS
        std::lock_guard<std::mutex> guard(m_mutexRegArrays);
#endif
        m_regObservers.del(it);
    }
 
protected:
    const ListPure<TObserver*>& getObservers() const { return m_regObservers; }
 
    void clearObservers() {
        while (!m_regObservers.empty()) {
            TObserver* obs = m_regObservers.front();
            obs->reregister(nullptr);
            OGDF_ASSERT(m_regObservers.empty()
                    || (m_regObservers.front() != obs && m_regObservers.back() != obs));
        }
    }
};
}