listenercontainer.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
#define INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
 
#include <algorithm>
#include <memory>
#include <vector>
#include <iterator>
 
namespace slideshow::internal {
 
struct EmptyBase
{
    struct EmptyGuard{ explicit EmptyGuard(EmptyBase) {} };
    struct EmptyClearableGuard
    {
        explicit EmptyClearableGuard(EmptyBase) {}
        static void clear() {}
    };
 
    typedef EmptyGuard           Guard;
    typedef EmptyClearableGuard ClearableGuard;
};
 
template< typename result_type, typename ListenerTargetT > struct FunctionApply
{
    template<typename FuncT> static bool apply(
        FuncT           func,
        ListenerTargetT const& rArg )
    {
        return func(rArg);
    }
};
 
template<typename ListenerTargetT> struct FunctionApply<void,ListenerTargetT>
{
    template<typename FuncT> static bool apply(
        FuncT                  func,
        ListenerTargetT const& rArg )
    {
        func(rArg);
        return true;
    }
};
 
template< typename ListenerT > struct ListenerOperations
{
    template< typename ContainerT,
              typename FuncT >
    static bool notifySingleListener( ContainerT& rContainer,
                                      FuncT       func )
    {
        // true: a handler in this queue processed the event
        // false: no handler in this queue finally processed the event
        return std::any_of( rContainer.begin(),
                            rContainer.end(),
                            func );
    }
 
    template< typename ContainerT,
              typename FuncT >
    static bool notifyAllListeners( ContainerT& rContainer,
                                    FuncT       func )
    {
        bool bRet(false);
        for( const auto& rCurr : rContainer )
        {
            if( FunctionApply< typename ::std::invoke_result< FuncT, const typename ContainerT::value_type& >::type,
                               typename ContainerT::value_type >::apply(
                                   func,
                                   rCurr) )
            {
                bRet = true;
            }
        }
 
        // true: at least one handler returned true
        // false: not a single handler returned true
        return bRet;
    }
 
    template< typename ContainerT >
    static void pruneListeners( ContainerT&, size_t )
    {
    }
};
 
template< typename ListenerTargetT >
struct ListenerOperations< std::weak_ptr<ListenerTargetT> >
{
    template< typename ContainerT,
              typename FuncT >
    static bool notifySingleListener( ContainerT& rContainer,
                                      FuncT       func )
    {
        for( const auto& rCurr : rContainer )
        {
            std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
 
            if( pListener && func(pListener) )
                return true;
        }
 
        return false;
    }
 
    template< typename ContainerT,
              typename FuncT >
    static bool notifyAllListeners( ContainerT& rContainer,
                                    FuncT       func )
    {
        bool bRet(false);
        for( const auto& rCurr : rContainer )
        {
            std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
 
            if( pListener.get() &&
                FunctionApply<typename ::std::invoke_result<FuncT, std::shared_ptr<ListenerTargetT> const&>::type,
                               std::shared_ptr<ListenerTargetT> >::apply(func,pListener) )
            {
                bRet = true;
            }
        }
 
        return bRet;
    }
    template< typename ContainerT >
    static void pruneListeners( ContainerT& rContainer,
                                size_t      nSizeThreshold )
    {
        if( rContainer.size() <= nSizeThreshold )
            return;
 
        ContainerT aAliveListeners;
        aAliveListeners.reserve(rContainer.size());
 
        for( const auto& rCurr : rContainer )
        {
            if( !rCurr.expired() )
                aAliveListeners.push_back( rCurr );
        }
 
        std::swap( rContainer, aAliveListeners );
    }
};
 
template< typename ListenerT,
          typename MutexHolderBaseT,
          typename ContainerT=std::vector<ListenerT>,
          size_t MaxDeceasedListenerUllage=16 > class ListenerContainerBase : public MutexHolderBaseT
{
    typedef typename MutexHolderBaseT::Guard           Guard;
    typedef typename MutexHolderBaseT::ClearableGuard  ClearableGuard;
 
public:
    typedef ListenerT        listener_type;
    typedef ContainerT       container_type;
 
    bool isEmpty() const
    {
        Guard aGuard(*this);
        return maListeners.empty();
    }
 
    bool isAdded( listener_type const& rListener ) const
    {
        Guard aGuard(*this);
 
        const typename container_type::const_iterator aEnd( maListeners.end() );
        if( std::find( maListeners.begin(),
                       aEnd,
                       rListener ) != aEnd )
        {
            return true; // already added
        }
 
        return false;
    }
 
    void add( listener_type const& rListener )
    {
        Guard aGuard(*this);
 
        // ensure uniqueness
        if( isAdded(rListener) )
            return; // already added
 
        maListeners.push_back( rListener );
 
        ListenerOperations<ListenerT>::pruneListeners(
            maListeners,
            MaxDeceasedListenerUllage);
    }
 
    bool addSorted( listener_type const& rListener )
    {
        Guard aGuard(*this);
 
        // ensure uniqueness
        if( isAdded(rListener) )
            return false; // already added
 
        maListeners.push_back( rListener );
 
        // a single entry does not need to be sorted
        if( maListeners.size() > 1 )
        {
            std::inplace_merge(
                maListeners.begin(),
                std::prev(maListeners.end()),
                maListeners.end() );
        }
 
        ListenerOperations<ListenerT>::pruneListeners(
            maListeners,
            MaxDeceasedListenerUllage);
 
        return true;
    }
 
    bool remove( listener_type const& rListener )
    {
        Guard aGuard(*this);
 
        const typename container_type::iterator aEnd( maListeners.end() );
        typename container_type::iterator       aIter;
        if( (aIter=std::remove(maListeners.begin(),
                               aEnd,
                               rListener)) == aEnd )
        {
            return false; // listener not found
        }
 
        maListeners.erase( aIter, aEnd );
 
        return true;
    }
 
    void clear()
    {
        Guard aGuard(*this);
 
        maListeners.clear();
    }
 
    template< typename FuncT > bool apply( FuncT func ) const
    {
        ClearableGuard aGuard(*this);
 
        // generate a local copy of all handlers, to make method
        // reentrant and thread-safe.
        container_type const local( maListeners );
        aGuard.clear();
 
        const bool bRet(
            ListenerOperations<ListenerT>::notifySingleListener(
                local,
                func ));
 
        {
            Guard aGuard2(*this);
            ListenerOperations<ListenerT>::pruneListeners(
                const_cast<container_type&>(maListeners),
                MaxDeceasedListenerUllage);
        }
 
        return bRet;
    }
 
    template< typename FuncT > bool applyAll( FuncT func ) const
    {
        ClearableGuard aGuard(*this);
 
        // generate a local copy of all handlers, to make method
        // reentrant and thread-safe.
        container_type const local( maListeners );
        aGuard.clear();
 
        const bool bRet(
            ListenerOperations<ListenerT>::notifyAllListeners(
                local,
                func ));
 
        {
            Guard aGuard2(*this);
            ListenerOperations<ListenerT>::pruneListeners(
                const_cast<container_type&>(maListeners),
                MaxDeceasedListenerUllage);
        }
 
        return bRet;
    }
 
private:
    ContainerT  maListeners;
};
 
 
template< typename ListenerT,
          typename ContainerT=std::vector<ListenerT> >
class ThreadUnsafeListenerContainer : public ListenerContainerBase<ListenerT,
                                                                   EmptyBase,
                                                                   ContainerT>
{
};
 
} // namespace slideshow::internal
 
#endif // INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */