observable.h

Go to the documentation of this file.

/*
* This program source code file is part of KICAD, a free EDA CAD application.
*
* Copyright The KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef COMMON_OBSERVABLE_H__
#define COMMON_OBSERVABLE_H__
 
#include <cassert>
#include <memory>
#include <vector>
#include <utility>

namespace UTIL
{
class LINK;
 
namespace DETAIL
{
    struct OBSERVABLE_BASE
    {
    public:
        OBSERVABLE_BASE();
        OBSERVABLE_BASE( OBSERVABLE_BASE& other );
 
        ~OBSERVABLE_BASE();
 
        size_t size() const;
 
    private:
        friend class UTIL::LINK;
 
        struct IMPL
        {
            IMPL( OBSERVABLE_BASE* owned_by = nullptr );
            bool is_shared() const;
            void set_shared();
            ~IMPL();
 
            void add_observer( void* observer );
            void remove_observer( void* observer );
            void collect();
 
            bool is_iterating() const;
 
            void enter_iteration();
            void leave_iteration();
 
            std::vector<void*> observers_;
            unsigned int       iteration_count_;
            OBSERVABLE_BASE*   owned_by_;
        };
 
        void allocate_impl();
        void allocate_shared_impl();
 
        void deallocate_impl();
 
        std::shared_ptr<IMPL> get_shared_impl();
 
    protected:
        void on_observers_empty();
 
        void enter_iteration();
        void leave_iteration();
 
        void add_observer( void* observer );
        void remove_observer( void* observer );
 
        std::shared_ptr<IMPL> impl_;
    };
 
} // namespace DETAIL
 

class LINK
{
public:
    LINK();
    LINK( std::shared_ptr<DETAIL::OBSERVABLE_BASE::IMPL> token, void* observer );
    LINK( LINK&& other );
    LINK( const LINK& ) = delete;
 
    void  operator=( const LINK& ) = delete;
    LINK& operator=( LINK&& other );
 
    void reset();
 
    explicit operator bool() const;
 
    ~LINK();
 
private:
    std::shared_ptr<DETAIL::OBSERVABLE_BASE::IMPL> token_;
    void*                                          observer_;
};
 
 
template <typename ObserverInterface>
class OBSERVABLE : public DETAIL::OBSERVABLE_BASE
{
public:
    OBSERVABLE() {}

    OBSERVABLE( OBSERVABLE& aInherit ) : OBSERVABLE_BASE( aInherit ) {}

    void SubscribeUnmanaged( ObserverInterface* aObserver )
    {
        OBSERVABLE_BASE::add_observer( static_cast<void*>( aObserver ) );
    }

    LINK Subscribe( ObserverInterface* aObserver )
    {
        OBSERVABLE_BASE::add_observer( static_cast<void*>( aObserver ) );
        return LINK( impl_, static_cast<void*>( aObserver ) );
    }

    void Unsubscribe( ObserverInterface* aObserver )
    {
        OBSERVABLE_BASE::remove_observer( static_cast<void*>( aObserver ) );
    }

    template <typename... Args1, typename... Args2>
    void Notify( void ( ObserverInterface::*Ptr )( Args1... ), Args2&&... aArgs )
    {
        static_assert( sizeof...( Args1 ) == sizeof...( Args2 ), "argument counts don't match" );
 
        if( impl_ )
        {
            enter_iteration();
            try
            {
                for( auto* void_ptr : impl_->observers_ )
                {
                    if( void_ptr )
                    {
                        auto* typed_ptr = static_cast<ObserverInterface*>( void_ptr );
                        ( typed_ptr->*Ptr )( std::forward<Args2>( aArgs )... );
                    }
                }
            }
            catch( ... )
            {
                leave_iteration();
                throw;
            }
 
            leave_iteration();
        }
    }

    template <typename... Args1, typename... Args2>
    void NotifyIgnore( void ( ObserverInterface::*Ptr )( Args1... ), ObserverInterface* aIgnore,
                       Args2&&... aArgs )
    {
        static_assert( sizeof...( Args1 ) == sizeof...( Args2 ), "argument counts don't match" );
 
        if( impl_ )
        {
            enter_iteration();
 
            try
            {
                for( auto* void_ptr : impl_->observers_ )
                {
                    if( void_ptr && void_ptr != aIgnore )
                    {
                        auto* typed_ptr = static_cast<ObserverInterface*>( void_ptr );
                        ( typed_ptr->*Ptr )( std::forward<Args2>( aArgs )... );
                    }
                }
            }
            catch( ... )
            {
                leave_iteration();
                throw;
            }
 
        }
    }
};
 
} // namespace UTIL
 
#endif