multiinterfacecontainer4.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 .
 */
#pragma once
#include <sal/config.h>
#include <com/sun/star/lang/EventObject.hpp>
#include <comphelper/interfacecontainer4.hxx>
#include <memory>
#include <mutex>
#include <vector> //for docpp
namespace comphelper
{
template <class key, class listener, class equalImpl = std::equal_to<key>>
class OMultiTypeInterfaceContainerHelperVar4
{
public:
    OMultiTypeInterfaceContainerHelperVar4() {}
    inline std::vector<key> getContainedTypes(std::unique_lock<std::mutex>& rGuard) const
    {
        assert(rGuard.owns_lock());
        std::vector<key> aInterfaceTypes;
        aInterfaceTypes.reserve(m_aMap.size());
        for (const auto& rPair : m_aMap)
            // are interfaces added to this container?
            if (rPair.second->getLength(rGuard))
                // yes, put the type in the array
                aInterfaceTypes.push_back(rPair.first);
        return aInterfaceTypes;
    }
    inline bool hasContainedTypes(std::unique_lock<std::mutex>& rGuard) const
    {
        assert(rGuard.owns_lock());
        for (const auto& rPair : m_aMap)
            // are interfaces added to this container?
            if (rPair.second->getLength(rGuard))
                return true;
        return false;
    }
    inline OInterfaceContainerHelper4<listener>* getContainer(std::unique_lock<std::mutex>& rGuard,
                                                              const key& rKey) const
    {
        auto iter = find(rGuard, rKey);
        if (iter != m_aMap.end())
            return (*iter).second.get();
        return nullptr;
    }
    inline sal_Int32 addInterface(::std::unique_lock<::std::mutex>& rGuard, const key& rKey,
                                  const css::uno::Reference<listener>& rListener)
    {
        auto iter = find(rGuard, rKey);
        if (iter == m_aMap.end())
        {
            auto pLC = new OInterfaceContainerHelper4<listener>();
            m_aMap.emplace_back(rKey, pLC);
            return pLC->addInterface(rGuard, rListener);
        }
        else
            return (*iter).second->addInterface(rGuard, rListener);
    }
    inline sal_Int32 removeInterface(::std::unique_lock<::std::mutex>& rGuard, const key& rKey,
                                     const css::uno::Reference<listener>& rListener)
    {
        // search container with id nUik
        auto iter = find(rGuard, rKey);
        // container found?
        if (iter != m_aMap.end())
            return (*iter).second->removeInterface(rGuard, rListener);
        // no container with this id. Always return 0
        return 0;
    }
    inline void disposeAndClear(std::unique_lock<std::mutex>& rGuard,
                                const css::lang::EventObject& rEvt)
    {
        assert(rGuard.owns_lock());
        // create a copy, because do not fire event in a guarded section
        InterfaceMap tempMap;
        {
            tempMap = std::move(m_aMap);
        }
        rGuard.unlock();
        // So... we don't want to hold the normal mutex while we fire
        // the events, but the calling convention here wants a mutex, so
        // just create a temporary/fake one. Since the listeners we
        // are working with are now function-local, we don't really need
        // a mutex at all, but it's easier to create a fake one than
        // create a bunch of special-case code for this situation.
        std::mutex tempMutex;
        std::unique_lock tempGuard(tempMutex);
        for (auto& rPair : tempMap)
        {
            OInterfaceIteratorHelper4<listener> aIt(tempGuard, *rPair.second);
            while (aIt.hasMoreElements())
            {
                try
                {
                    aIt.next()->disposing(rEvt);
                }
                catch (css::uno::RuntimeException&)
                {
                    // be robust, if e.g. a remote bridge has disposed already.
                    // there is no way to delegate the error to the caller :o(.
                }
            }
        }
        rGuard.lock(); // return with lock in same state as entry
    }
    inline void clear(std::unique_lock<std::mutex>& rGuard)
    {
        assert(rGuard.owns_lock());
        (void)rGuard;
        for (const auto& rPair : m_aMap)
            rPair.second->clear();
    }
    typedef key keyType;
 
private:
    typedef ::std::vector<std::pair<key, std::unique_ptr<OInterfaceContainerHelper4<listener>>>>
        InterfaceMap;
    InterfaceMap m_aMap;
    typename InterfaceMap::const_iterator find(std::unique_lock<std::mutex>& rGuard,
                                               const key& rKey) const
    {
        assert(rGuard.owns_lock());
        (void)rGuard;
        auto iter = m_aMap.begin();
        auto end = m_aMap.end();
        while (iter != end)
        {
            equalImpl equal;
            if (equal(iter->first, rKey))
                break;
            ++iter;
        }
        return iter;
    }
    OMultiTypeInterfaceContainerHelperVar4(const OMultiTypeInterfaceContainerHelperVar4&) = delete;
    OMultiTypeInterfaceContainerHelperVar4& operator=(const OMultiTypeInterfaceContainerHelperVar4&)
        = delete;
};
} // namespace comphelper
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */