observable.h

Go to the documentation of this file.

/*
* This program source code file is part of KICAD, a free EDA CAD application.
*
* Copyright (C) 2016-20 Kicad Developers, see change_log.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, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
 
#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;
 }
 
 leave_iteration();
 }
 }
};
 
} // namespace UTIL
 
#endif