sequenceashashmap.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_COMPHELPER_SEQUENCEASHASHMAP_HXX
#define INCLUDED_COMPHELPER_SEQUENCEASHASHMAP_HXX
 
#include <unordered_map>
#include <com/sun/star/uno/Sequence.hxx>
 
#include <comphelper/comphelperdllapi.h>
 
namespace com::sun::star::beans { struct NamedValue; }
namespace com::sun::star::beans { struct PropertyValue; }
 
namespace comphelper{
 
 
struct OUStringAndHashCode
{
    OUString maString;
    sal_Int32 mnHashCode;
 
    OUStringAndHashCode(OUString s) : maString(s), mnHashCode(maString.hashCode()) {}
};
struct OUStringAndHashCodeEqual
{
    bool operator()(const OUStringAndHashCode & lhs, const OUStringAndHashCode & rhs) const
    {
        return lhs.mnHashCode == rhs.mnHashCode && lhs.maString == rhs.maString;
    }
};
struct OUStringAndHashCodeHash
{
    size_t operator()(const OUStringAndHashCode & i) const
    {
        return i.mnHashCode;
    }
};
using SequenceAsHashMapBase = std::unordered_map<OUStringAndHashCode, css::uno::Any, OUStringAndHashCodeHash, OUStringAndHashCodeEqual>;
 
class SAL_WARN_UNUSED COMPHELPER_DLLPUBLIC SequenceAsHashMap
{
 
    public:
 
 
        SequenceAsHashMap();
 
 
        SequenceAsHashMap(const css::uno::Any& aSource);
 
 
        SequenceAsHashMap(const css::uno::Sequence< css::uno::Any >& lSource);
 
 
        SequenceAsHashMap(const css::uno::Sequence< css::beans::PropertyValue >& lSource);
 
 
        SequenceAsHashMap(const css::uno::Sequence< css::beans::NamedValue >& lSource);
 
 
        void operator<<(const css::uno::Any& aSource);
 
 
        void operator<<(const css::uno::Sequence< css::uno::Any >& lSource);
 
 
        void operator<<(const css::uno::Sequence< css::beans::PropertyValue >& lSource);
 
 
        void operator<<(const css::uno::Sequence< css::beans::NamedValue >& lSource);
 
 
        void operator>>(css::uno::Sequence< css::beans::PropertyValue >& lDestination) const;
 
 
        void operator>>(css::uno::Sequence< css::beans::NamedValue >& lDestination) const;
 
 
        css::uno::Any getAsConstAny(bool bAsPropertyValue) const;
 
 
        css::uno::Sequence< css::beans::NamedValue > getAsConstNamedValueList() const;
 
 
        css::uno::Sequence< css::beans::PropertyValue > getAsConstPropertyValueList() const;
 
 
        template< class TValueType >
        TValueType getUnpackedValueOrDefault(const OUString& sKey    ,
                                             const TValueType&      aDefault) const
        {
            auto pIt = m_aMap.find(sKey);
            if (pIt == m_aMap.end())
                return aDefault;
 
            TValueType aValue = TValueType();
            if (!(pIt->second >>= aValue))
                return aDefault;
 
            return aValue;
        }
 
        css::uno::Any getValue(const OUString& sKey) const
        {
            auto pIt = m_aMap.find(sKey);
            if (pIt == m_aMap.end())
                return css::uno::Any();
 
            return pIt->second;
        }
 
 
        template< class TValueType >
        bool createItemIfMissing(const OUString& sKey  ,
                                     const TValueType&      aValue)
        {
            if (m_aMap.find(sKey) == m_aMap.end())
            {
                (*this)[sKey] = css::uno::toAny(aValue);
                return true;
            }
 
            return false;
        }
 
 
        bool match(const SequenceAsHashMap& rCheck) const;
 
 
        void update(const SequenceAsHashMap& rSource);
 
        css::uno::Any& operator[](const OUString& rKey)
        {
            return m_aMap[rKey];
        }
 
        css::uno::Any& operator[](const OUStringAndHashCode& rKey)
        {
            return m_aMap[rKey];
        }
 
        using iterator = SequenceAsHashMapBase::iterator;
        using const_iterator = SequenceAsHashMapBase::const_iterator;
 
        void clear()
        {
            m_aMap.clear();
        }
 
        size_t size() const
        {
            return m_aMap.size();
        }
 
        bool empty() const
        {
            return m_aMap.empty();
        }
 
        iterator begin()
        {
            return m_aMap.begin();
        }
 
        const_iterator begin() const
        {
            return m_aMap.begin();
        }
 
        iterator end()
        {
            return m_aMap.end();
        }
 
        const_iterator end() const
        {
            return m_aMap.end();
        }
 
        iterator find(const OUString& rKey)
        {
            return m_aMap.find(rKey);
        }
 
        const_iterator find(const OUString& rKey) const
        {
            return m_aMap.find(rKey);
        }
 
        iterator find(const OUStringAndHashCode& rKey)
        {
            return m_aMap.find(rKey);
        }
 
        const_iterator find(const OUStringAndHashCode& rKey) const
        {
            return m_aMap.find(rKey);
        }
 
        iterator erase(iterator it)
        {
            return m_aMap.erase(it);
        }
 
        size_t erase(const OUString& rKey)
        {
            return m_aMap.erase(rKey);
        }
 
private:
        SequenceAsHashMapBase m_aMap;
};
 
} // namespace comphelper
 
#endif // INCLUDED_COMPHELPER_SEQUENCEASHASHMAP_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */