multiinterfacecontainer3.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/interfacecontainer3.hxx>
#include <memory>
#include <vector>
 
namespace osl
{
class Mutex;
}
 
namespace comphelper
{
template <class listener, class key, class equalImpl = std::equal_to<key>>
class OMultiTypeInterfaceContainerHelperVar3
{
public:
    inline OMultiTypeInterfaceContainerHelperVar3(::osl::Mutex& rMutex_)
        : rMutex(rMutex_)
    {
    }
 
    inline std::vector<key> getContainedTypes() const
    {
        ::osl::MutexGuard aGuard(rMutex);
        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())
                // yes, put the type in the array
                aInterfaceTypes.push_back(rPair.first);
        return aInterfaceTypes;
    }
 
    inline bool hasContainedTypes() const
    {
        ::osl::MutexGuard aGuard(rMutex);
        for (const auto& rPair : m_aMap)
            // are interfaces added to this container?
            if (rPair.second->getLength())
                return true;
        return false;
    }
 
    inline OInterfaceContainerHelper3<listener>* getContainer(const key& rKey) const
    {
        ::osl::MutexGuard aGuard(rMutex);
 
        auto iter = find(rKey);
        if (iter != m_aMap.end())
            return (*iter).second.get();
        return nullptr;
    }
 
    inline sal_Int32 addInterface(const key& rKey, const css::uno::Reference<listener>& rListener)
    {
        ::osl::MutexGuard aGuard(rMutex);
        auto iter = find(rKey);
        if (iter == m_aMap.end())
        {
            auto pLC = new OInterfaceContainerHelper3<listener>(rMutex);
            m_aMap.emplace_back(rKey, pLC);
            return pLC->addInterface(rListener);
        }
        else
            return (*iter).second->addInterface(rListener);
    }
 
    inline sal_Int32 removeInterface(const key& rKey,
                                     const css::uno::Reference<listener>& rListener)
    {
        ::osl::MutexGuard aGuard(rMutex);
 
        // search container with id nUik
        auto iter = find(rKey);
        // container found?
        if (iter != m_aMap.end())
            return (*iter).second->removeInterface(rListener);
 
        // no container with this id. Always return 0
        return 0;
    }
 
    inline void disposeAndClear(const css::lang::EventObject& rEvt)
    {
        // create a copy, because do not fire event in a guarded section
        InterfaceMap tempMap;
        {
            ::osl::MutexGuard aGuard(rMutex);
            tempMap = std::move(m_aMap);
        }
 
        for (auto& rPair : tempMap)
            rPair.second->disposeAndClear(rEvt);
    }
 
    inline void clear()
    {
        ::osl::MutexGuard aGuard(rMutex);
 
        for (const auto& rPair : m_aMap)
            rPair.second->clear();
    }
 
    typedef key keyType;
 
private:
    typedef ::std::vector<std::pair<key, std::unique_ptr<OInterfaceContainerHelper3<listener>>>>
        InterfaceMap;
    InterfaceMap m_aMap;
    ::osl::Mutex& rMutex;
 
    typename InterfaceMap::const_iterator find(const key& rKey) const
    {
        auto iter = m_aMap.begin();
        auto end = m_aMap.end();
 
        while (iter != end)
        {
            equalImpl equal;
            if (equal(iter->first, rKey))
                break;
            ++iter;
        }
        return iter;
    }
 
    OMultiTypeInterfaceContainerHelperVar3(const OMultiTypeInterfaceContainerHelperVar3&) = delete;
    OMultiTypeInterfaceContainerHelperVar3& operator=(const OMultiTypeInterfaceContainerHelperVar3&)
        = delete;
};
 
} // namespace comphelper
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */