/* -*- 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 .

 */

#include <string.h>

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <unordered_map>

#include <libxml/xmlwriter.h>

#include <tools/XmlWriter.hxx>

#include <o3tl/hash_combine.hxx>

#include <sal/log.hxx>

#include <svl/itemset.hxx>

#include <svl/itempool.hxx>

#include <svl/itemiter.hxx>

#include <svl/setitem.hxx>

#include <svl/whiter.hxx>

#include <svl/voiditem.hxx>

#ifdef DBG_UTIL

static size_t nAllocatedSfxItemSetCount(0);

static size_t nUsedSfxItemSetCount(0);

static size_t nAllocatedSfxPoolItemHolderCount(0);

static size_t nUsedSfxPoolItemHolderCount(0);

size_t getAllocatedSfxItemSetCount() { return nAllocatedSfxItemSetCount; }

size_t getUsedSfxItemSetCount() { return nUsedSfxItemSetCount; }

size_t getAllocatedSfxPoolItemHolderCount() { return nAllocatedSfxPoolItemHolderCount; }

size_t getUsedSfxPoolItemHolderCount() { return nUsedSfxPoolItemHolderCount; }

// <TotalCount, <number of entries, sum of used count>>

typedef std::unordered_map<sal_uInt16, std::pair<sal_uInt32, sal_uInt32>> ItemArrayUsage;

static ItemArrayUsage aItemArrayUsage;

static void addArrayUsage(sal_uInt16 nCount, sal_uInt16 nTotalCount)

{

    ItemArrayUsage::iterator aHit(aItemArrayUsage.find(nTotalCount));

    if (aHit == aItemArrayUsage.end())

    {

        aItemArrayUsage.insert({nTotalCount, {1, nCount}});

        return;

    }

    aHit->second.first++;

    aHit->second.second += nCount;

}

SVL_DLLPUBLIC void listSfxItemSetUsage()

{

    struct sorted {

        sal_uInt16 nTotalCount;

        sal_uInt32 nAppearances;

        sal_uInt32 nAllUsedCount;

        sorted(sal_uInt16 _nTotalCount, sal_uInt32 _nAppearances, sal_uInt32 _nAllUsedCount)

            : nTotalCount(_nTotalCount), nAppearances(_nAppearances), nAllUsedCount(_nAllUsedCount) {}

        bool operator<(const sorted& rDesc) const { return nTotalCount > rDesc.nTotalCount; }

    };

    std::vector<sorted> aSorted;

    aSorted.reserve(aItemArrayUsage.size());

    for (const auto& rEntry : aItemArrayUsage)

        aSorted.emplace_back(rEntry.first, rEntry.second.first, rEntry.second.second);

    std::sort(aSorted.begin(), aSorted.end());

    SAL_INFO("svl.items", "ITEM: List of " << aItemArrayUsage.size() << " SfxItemPool TotalCounts with usages:");

    double fAllFillRatePercent(0.0);

    sal_uInt32 nUsed(0);

    sal_uInt32 nAllocated(0);

    for (const auto& rEntry : aSorted)

    {

        const sal_uInt32 nAllCount(rEntry.nAppearances * rEntry.nTotalCount);

        const double fFillRatePercent(0 == nAllCount ? 0.0 : (static_cast<double>(rEntry.nAllUsedCount) / static_cast<double>(nAllCount)) * 100.0);

        SAL_INFO("svl.items",

            " TotalCount: " << rEntry.nTotalCount

            << " Appearances: " << rEntry.nAppearances

            << " FillRate(%): " << fFillRatePercent);

        fAllFillRatePercent += fFillRatePercent;

        nUsed += rEntry.nAllUsedCount;

        nAllocated += rEntry.nTotalCount * rEntry.nAppearances;

    }

    SAL_INFO("svl.items", " Average FillRate(%): " << fAllFillRatePercent / aItemArrayUsage.size());

    SAL_INFO("svl.items", " Used: " << nUsed << " Allocated: " << nAllocated);

    SAL_INFO("svl.items", " Average Used/Allocated(%): " << (static_cast<double>(nUsed) / static_cast<double>(nAllocated)) * 100.0);

}

#endif

// NOTE: Only needed for one Item in SC (see notes below for

// ScPatternAttr). Still keep it so that when errors

// come up to this change be able to quickly check using the

// fallback flag 'ITEM_CLASSIC_MODE'

// I thought about this constructor a while, but when there is no

// Item we need no cleanup at destruction (what we would need the

// Pool for), so it is OK and makes default construction easier

// when no Pool is needed. The other constructors guarantee that

// there *cannot* be a state with Item set and Pool not set. IF

// you change this class, ALWAYS ensure that this can not happen (!)

SfxPoolItemHolder::SfxPoolItemHolder()

: m_pPool(nullptr)

, m_pItem(nullptr)

#ifndef NDEBUG

, m_bDeleted(false)

#endif

{

#ifdef DBG_UTIL

    nAllocatedSfxPoolItemHolderCount++;

    nUsedSfxPoolItemHolderCount++;

#endif

}

SfxPoolItemHolder::SfxPoolItemHolder(SfxItemPool& rPool, const SfxPoolItem* pItem, bool bPassingOwnership)

: m_pPool(&rPool)

, m_pItem(pItem)

#ifndef NDEBUG

, m_bDeleted(false)

#endif

{

#ifdef DBG_UTIL

    nAllocatedSfxPoolItemHolderCount++;

    nUsedSfxPoolItemHolderCount++;

#endif

    if (nullptr != m_pItem)

        m_pItem = implCreateItemEntry(getPool(), m_pItem, bPassingOwnership);

    if (nullptr != m_pItem && getPool().NeedsSurrogateSupport(m_pItem->Which()))

        getPool().registerPoolItemHolder(*this);

}

SfxPoolItemHolder::SfxPoolItemHolder(const SfxPoolItemHolder& rHolder)

: m_pPool(rHolder.m_pPool)

, m_pItem(rHolder.m_pItem)

#ifndef NDEBUG

, m_bDeleted(false)

#endif

{

#ifdef DBG_UTIL

    assert(!rHolder.isDeleted() && "Destructed instance used (!)");

    nAllocatedSfxPoolItemHolderCount++;

    nUsedSfxPoolItemHolderCount++;

#endif

    if (nullptr != m_pItem)

        m_pItem = implCreateItemEntry(getPool(), m_pItem, false);

    if (nullptr != m_pItem && getPool().NeedsSurrogateSupport(m_pItem->Which()))

        getPool().registerPoolItemHolder(*this);

}

SfxPoolItemHolder::~SfxPoolItemHolder()

{

#ifdef DBG_UTIL

    assert(!isDeleted() && "Destructed instance used (!)");

    nAllocatedSfxPoolItemHolderCount--;

#endif

    if (nullptr != m_pItem && getPool().NeedsSurrogateSupport(m_pItem->Which()))

        getPool().unregisterPoolItemHolder(*this);

    if (nullptr != m_pItem)

        implCleanupItemEntry(m_pItem);

#ifndef NDEBUG

    m_bDeleted = true;

#endif

}

const SfxPoolItemHolder& SfxPoolItemHolder::operator=(const SfxPoolItemHolder& rHolder)

{

    assert(!isDeleted() && "Destructed instance used (!)");

    assert(!rHolder.isDeleted() && "Destructed instance used (!)");

    if (this == &rHolder || *this == rHolder)

        return *this;

    if (nullptr != m_pItem && getPool().NeedsSurrogateSupport(m_pItem->Which()))

        getPool().unregisterPoolItemHolder(*this);

    if (nullptr != m_pItem)

        implCleanupItemEntry(m_pItem);

    m_pPool = rHolder.m_pPool;

    m_pItem = rHolder.m_pItem;

    if (nullptr != m_pItem)

        m_pItem = implCreateItemEntry(getPool(), m_pItem, false);

    if (nullptr != m_pItem && getPool().NeedsSurrogateSupport(m_pItem->Which()))

        getPool().registerPoolItemHolder(*this);

    return *this;

}

bool SfxPoolItemHolder::operator==(const SfxPoolItemHolder &rHolder) const

{

    assert(!isDeleted() && "Destructed instance used (!)");

    assert(!rHolder.isDeleted() && "Destructed instance used (!)");

    return m_pPool == rHolder.m_pPool && areSfxPoolItemPtrsEqual(m_pItem, rHolder.m_pItem);

}

/**

 * Ctor for a SfxItemSet with exactly the Which Ranges, which are known to

 * the supplied SfxItemPool.

 *

 * For Sfx programmers: an SfxItemSet constructed in this way cannot

 * contain any Items with SlotIds as Which values.

 */

SfxItemSet::SfxItemSet(SfxItemPool& rPool)

: m_pPool(&rPool)

, m_pParent(nullptr)

, m_nRegister(0)

#ifdef DBG_UTIL

, m_nRegisteredSfxItemIter(0)

, m_bDeleted(false)

#endif

, m_aWhichRanges(rPool.GetMergedIdRanges())

, m_aPoolItemMap()

{

#ifdef DBG_UTIL

    nAllocatedSfxItemSetCount++;

    nUsedSfxItemSetCount++;

#endif

    assert(m_aWhichRanges.validRanges2());

}

SfxItemSet::SfxItemSet(SfxItemPool& pool, WhichRangesContainer wids)

: m_pPool(&pool)

, m_pParent(nullptr)

, m_nRegister(0)

#ifdef DBG_UTIL

, m_nRegisteredSfxItemIter(0)

, m_bDeleted(false)

#endif

, m_aWhichRanges(std::move(wids))

, m_aPoolItemMap()

{

#ifdef DBG_UTIL

    nAllocatedSfxItemSetCount++;

    nUsedSfxItemSetCount++;

#endif

    assert(m_aWhichRanges.TotalCount() != 0);

    assert(m_aWhichRanges.validRanges2());

}

SfxItemSet::SfxItemSet( const SfxItemSet& rASet )

: m_pPool( rASet.m_pPool )

, m_pParent( rASet.m_pParent )

, m_nRegister( 0 )

#ifdef DBG_UTIL

, m_nRegisteredSfxItemIter(0)

, m_bDeleted(false)

#endif

, m_aWhichRanges( rASet.m_aWhichRanges )

, m_aPoolItemMap()

{

#ifdef DBG_UTIL

    nAllocatedSfxItemSetCount++;

    nUsedSfxItemSetCount++;

#endif

    if (rASet.GetRanges().empty())

        return;

    for (const auto& rSource : rASet.m_aPoolItemMap)

    {

        const SfxPoolItem* pNew(implCreateItemEntry(*GetPool(), rSource.second, false));

        m_aPoolItemMap[rSource.first] = pNew;

        if (m_nRegister != rASet.m_nRegister)

            checkAddPoolRegistration(pNew);

    }

    assert(m_aWhichRanges.validRanges2());

}

SfxItemSet::SfxItemSet(SfxItemSet&& rASet) noexcept

: m_pPool( rASet.m_pPool )

, m_pParent( rASet.m_pParent )

, m_nRegister( rASet.m_nRegister )

#ifdef DBG_UTIL

, m_nRegisteredSfxItemIter(0)

, m_bDeleted(false)

#endif

, m_aWhichRanges( std::move(rASet.m_aWhichRanges) )

, m_aPoolItemMap( std::move(rASet.m_aPoolItemMap) )

{

#ifdef DBG_UTIL

    nAllocatedSfxItemSetCount++;

    nUsedSfxItemSetCount++;

    assert(0 == rASet.m_nRegisteredSfxItemIter && "ITEM: SfxItemSet MOVE constructor with active SfxItemIters (!)");

#endif

    // deregister if rASet is registered before ptrs vanish

    if (0 != rASet.m_nRegister)

        rASet.GetPool()->unregisterItemSet(rASet);

    // register if new set needs that

    if (0 != m_nRegister)

        GetPool()->registerItemSet(*this);

    // taking over ownership

    rASet.m_pPool = nullptr;

    rASet.m_pParent = nullptr;

    rASet.m_nRegister = 0;

    rASet.m_aWhichRanges.reset();

    assert(m_aWhichRanges.validRanges2());

}

SfxItemSet::~SfxItemSet()

{

#ifdef DBG_UTIL

    nAllocatedSfxItemSetCount--;

    addArrayUsage(Count(), TotalCount());

#endif

    // cleanup items. No std::fill needed, we are done with this ItemSet.

    // the callback is not set in destructor, so no worries about that

    ClearAllItemsImpl();

    // for invariant-testing

    m_aWhichRanges.reset();

#ifdef DBG_UTIL

    m_bDeleted = true;

#endif

}

// Delete single Items or all Items (nWhich == 0)

sal_uInt16 SfxItemSet::ClearItem( sal_uInt16 nWhich )

{

    if( !Count() )

        return 0;

    if( nWhich )

        return ClearSingleItem_ForWhichID(nWhich);

    // clear all & reset to nullptr

    return ClearAllItemsImpl();

}

sal_uInt16 SfxItemSet::ClearSingleItem_ForWhichID( sal_uInt16 nWhich )

{

    PoolItemMap::iterator aHit(m_aPoolItemMap.find(nWhich));

    if (aHit == m_aPoolItemMap.end())

        return 0;

#ifdef DBG_UTIL

    assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet ClearItem with active SfxItemIters (!)");

#endif

    ClearSingleItem_PrepareRemove(aHit->second);

    m_aPoolItemMap.erase(aHit);

    return 1;

}

void SfxItemSet::ClearSingleItem_PrepareRemove(const SfxPoolItem* pItem)

{

    if (nullptr == pItem)

        return;

    // Notification-Callback

    Changed(pItem, nullptr);

    // check register for remove

    checkRemovePoolRegistration(pItem);

    // cleanup item & reset ptr

    implCleanupItemEntry(pItem);

}

void SfxItemSet::checkRemovePoolRegistration(const SfxPoolItem* pItem)

{

    if (nullptr == pItem)

        // no Item, done

        return;

    if (IsInvalidItem(pItem) || IsDisabledItem(pItem))

        // checks IsInvalidItem/IsDisabledItem

        return;

    if (SfxItemPool::IsSlot(pItem->Which()))

        // no slots, these do not support NeedsSurrogateSupport

        return;

    if(!GetPool()->NeedsSurrogateSupport(pItem->Which()))

        // not needed for this item, done

        return;

    // there must be a registered one

    assert(0 != m_nRegister);

    // decrement counter

    m_nRegister--;

    // deregister when no more Items that NeedsSurrogateSupport exist

    if (0 == m_nRegister)

        GetPool()->unregisterItemSet(*this);

    if (pItem->isNameOrIndex())

        GetPool()->unregisterNameOrIndex(*pItem);

}

void SfxItemSet::checkAddPoolRegistration(const SfxPoolItem* pItem)

{

    if (nullptr == pItem)

        // no Item, done

        return;

    if (IsInvalidItem(pItem) || IsDisabledItem(pItem))

        // checks IsInvalidItem/IsDisabledItem

        return;

    if (SfxItemPool::IsSlot(pItem->Which()))

        // no slots, these do not support NeedsSurrogateSupport

        return;

    if(!GetPool()->NeedsSurrogateSupport(pItem->Which()))

        // not needed for this item, done

        return;

    // register when first Item that NeedsSurrogateSupport exist

    if (0 == m_nRegister)

        GetPool()->registerItemSet(*this);

    if (pItem->isNameOrIndex())

        GetPool()->registerNameOrIndex(*pItem);

    // increment counter

    m_nRegister++;

}

sal_uInt16 SfxItemSet::ClearAllItemsImpl()

{

    if (0 == Count())

        // no items set, done

        return 0;

#ifdef DBG_UTIL

    assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet ClearAllItems with active SfxItemIters (!)");

#endif

    // loop & cleanup items

    for (const auto& rCandidate : m_aPoolItemMap)

        ClearSingleItem_PrepareRemove(rCandidate.second);

    // remember count before resetting it, that is the retval

    const sal_uInt16 nRetval(Count());

    m_aPoolItemMap.clear();

    if (0 != m_nRegister)

    {

        GetPool()->unregisterItemSet(*this);

        m_nRegister = 0;

    }

    return nRetval;

}

void SfxItemSet::ClearInvalidItems()

{

    if (0 == Count())

        // no items set, done

        return;

    // loop, here using const_iterator due to need to set ptr in m_ppItems array

    for (PoolItemMap::iterator aCandidate(m_aPoolItemMap.begin()); aCandidate != m_aPoolItemMap.end();)

    {

        if (IsInvalidItem(aCandidate->second))

        {

#ifdef DBG_UTIL

            assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet ClearInvalidItems with active SfxItemIters (!)");

#endif

            aCandidate = m_aPoolItemMap.erase(aCandidate);

        }

        else

            aCandidate++;

    }

}

SfxItemState SfxItemSet::GetItemState_ForIter(PoolItemMap::const_iterator aHit, const SfxPoolItem **ppItem)

{

    if (IsInvalidItem(aHit->second))

        // Different ones are present

        return SfxItemState::INVALID;

    if (IsDisabledItem(aHit->second))

        // Item is Disabled

        return SfxItemState::DISABLED;

    // if we have the Item, add it to output an hand back

    if (nullptr != ppItem)

        *ppItem = aHit->second;

    // Item is set

    return SfxItemState::SET;

}

SfxItemState SfxItemSet::GetItemState_ForWhichID( SfxItemState eState, sal_uInt16 nWhich, bool bSrchInParent, const SfxPoolItem **ppItem) const

{

    if (m_pAccessTracker && !m_bAccessTrackerIgnore) {

        if (std::find(m_pAccessTracker->begin(), m_pAccessTracker->end(), nWhich)

                == m_pAccessTracker->end())

            m_pAccessTracker->push_back(nWhich);

    }

    PoolItemMap::const_iterator aHit(m_aPoolItemMap.find(nWhich));

    if (aHit != m_aPoolItemMap.end())

        return GetItemState_ForIter(aHit, ppItem);

    if (GetRanges().doesContainWhich(nWhich))

    {

        // set to Default

        eState = SfxItemState::DEFAULT;

    }

    // search in parent?

    if (bSrchInParent && nullptr != GetParent() && (SfxItemState::UNKNOWN == eState || SfxItemState::DEFAULT == eState))

    {

        // Use the *highest* SfxItemState as result

        return GetParent()->GetItemState_ForWhichID( eState, nWhich, true, ppItem);

    }

    return eState;

}

bool SfxItemSet::HasItem(sal_uInt16 nWhich, const SfxPoolItem** ppItem) const

{

    if (m_pAccessTracker && !m_bAccessTrackerIgnore) {

        if (std::find(m_pAccessTracker->begin(), m_pAccessTracker->end(), nWhich)

                == m_pAccessTracker->end())

            m_pAccessTracker->push_back(nWhich);

    }

    const bool bRet(SfxItemState::SET == GetItemState_ForWhichID(SfxItemState::UNKNOWN, nWhich, true, ppItem));

    // we need to reset ppItem when it was *not* set by GetItemState_ForWhichID

    // since many usages of that return parameter re-use it, so it might still

    // be set to 'something'

    if (!bRet && nullptr != ppItem)

    {

        *ppItem = nullptr;

    }

    return bRet;

}

void SfxItemSet::CollectHasItems(std::vector<sal_uInt16>& rItemWhichs) const

{

    for(auto const & rPair : m_aWhichRanges)

    {

        const sal_uInt16 nBeg = rPair.first;

        const sal_uInt16 nEnd = rPair.second;

        for( sal_uInt16 nWhich = nBeg; nWhich <= nEnd; ++nWhich )

        {

            bool bHasItem = false;

            auto aHit(m_aPoolItemMap.find(nWhich));

            if (aHit != m_aPoolItemMap.end())

            {

                bHasItem = !IsInvalidItem(aHit->second) && !IsDisabledItem(aHit->second);

            }

            else

            {

                if (m_pParent)

                    bHasItem = SfxItemState::SET == m_pParent->GetItemState_ForWhichID( SfxItemState::DEFAULT, nWhich, true, nullptr);

            }

            if (bHasItem)

                rItemWhichs.push_back( nWhich );

        }

    }

}

const SfxPoolItem* SfxItemSet::PutImplAsTargetWhich(const SfxPoolItem& rItem, sal_uInt16 nTargetWhich, bool bPassingOwnership)

{

    if (0 == nTargetWhich || nTargetWhich == rItem.Which())

        // nTargetWhich not different or not given, use default

        return PutImpl(rItem, bPassingOwnership);

    if (bPassingOwnership && 0 == rItem.GetRefCount())

    {

        // we *can* use rItem when it's not pooled AKA has no RefCount

        const_cast<SfxPoolItem&>(rItem).SetWhich(nTargetWhich);

        return PutImpl(rItem, true);

    }

    // else we have to create a clone, set WhichID at it and

    // delete rItem when bPassingOwnership was intended

    SfxPoolItem* pClone(rItem.Clone(GetPool()));

    pClone->SetWhich(nTargetWhich);

    if (bPassingOwnership)

        delete &rItem;

    return PutImpl(*pClone, true);

}

const SfxPoolItem* SfxItemSet::PutImpl(const SfxPoolItem& rItem, bool bPassingOwnership)

{

    if (IsDisabledItem(&rItem))

    {

        // no action needed: IsDisabledItem

        if (bPassingOwnership)

            delete &rItem;

        return nullptr;

    }

    const sal_uInt16 nWhich(rItem.Which());

    if (!GetRanges().doesContainWhich(nWhich))

    {

        // no action needed: not in WhichRange

        if (bPassingOwnership)

            delete &rItem;

        return nullptr;

    }

    const SfxPoolItem* pEntry(nullptr);

    PoolItemMap::iterator aHit(m_aPoolItemMap.find(nWhich));

    if (aHit != m_aPoolItemMap.end())

    {

        // compare items, evtl. containing content compare

        pEntry = aHit->second;

        if (SfxPoolItem::areSame(*pEntry, rItem))

        {

            // no action needed: identical item already in place

            if (bPassingOwnership)

                delete &rItem;

            return nullptr;

        }

    }

    // prepare new entry

    const SfxPoolItem* pNew(implCreateItemEntry(*GetPool(), &rItem, bPassingOwnership));

    // Notification-Callback

    Changed(pEntry, pNew);

    // check register for add/remove. add first so that unregister/register

    // is avoided when an Item is replaced (increase, decrease, do not reach 0)

    checkAddPoolRegistration(pNew);

    checkRemovePoolRegistration(pEntry);

    // cleanup old entry & set entry at m_ppItems array

    implCleanupItemEntry(pEntry);

    if (pEntry)

        aHit->second = pNew;

    else

    {

#ifdef DBG_UTIL

        assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet PutImpl with active SfxItemIters (!)");

#endif

        m_aPoolItemMap[nWhich] = pNew;

    }

    return pNew;

}

bool SfxItemSet::Put(const SfxItemSet& rSource, bool bInvalidAsDefault)

{

    if (0 == rSource.Count())

        // no items in source, done

        return false;

    bool bRetval(false);

    for (PoolItemMap::const_iterator aCandidate(rSource.m_aPoolItemMap.begin()); aCandidate != rSource.m_aPoolItemMap.end(); aCandidate++)

    {

        if (IsInvalidItem(aCandidate->second))

        {

            if (bInvalidAsDefault)

            {

                bRetval |= 0 != ClearSingleItem_ForWhichID(aCandidate->first);

            }

            else

            {

                DisableOrInvalidateItem_ForWhichID(false, aCandidate->first);

            }

        }

        else

        {

            bRetval |= nullptr != PutImpl(*aCandidate->second, false);

        }

    }

    return bRetval;

}

/**

 * This method takes the Items from the 'rSet' and adds to '*this'.

 * Which ranges in '*this' that are non-existent in 'rSet' will not

 * be altered. The Which range of '*this' is also not changed.

 *

 * Items set in 'rSet' are also set in '*this'.

 * Default (0 pointer) and Invalid (-1 pointer) Items are processed

 * according to their parameter 'eDontCareAs' and 'eDefaultAs':

 *

 * SfxItemState::SET:       Hard set to the default of the Pool

 * SfxItemState::DEFAULT:   Deleted (0 pointer)

 * SfxItemState::INVALID:  Invalid (-1 pointer)

 *

 * NB: All other values for 'eDontCareAs' and 'eDefaultAs' are invalid

 */

void SfxItemSet::PutExtended

(

    const SfxItemSet&   rSource,        // Source of the Items to be put

    SfxItemState        eDontCareAs,    // What will happen to the DontCare Items

    SfxItemState        eDefaultAs      // What will happen to the Default Items

)

{

    // don't "optimize" with "if( rSource.Count()" because of dontcare + defaults

    for (const WhichPair& rPair : rSource.GetRanges())

    {

        for (sal_uInt16 nWhich = rPair.first; nWhich <= rPair.second; nWhich++)

        {

            PoolItemMap::const_iterator aHit(rSource.m_aPoolItemMap.find(nWhich));

            if (aHit != rSource.m_aPoolItemMap.end())

            {

                if (IsInvalidItem(aHit->second))

                {

                    // Item is DontCare:

                    switch (eDontCareAs)

                    {

                        case SfxItemState::SET:

                            PutImpl(rSource.GetPool()->GetUserOrPoolDefaultItem(nWhich), false);

                            break;

                        case SfxItemState::DEFAULT:

                            ClearSingleItem_ForWhichID(nWhich);

                            break;

                        case SfxItemState::INVALID:

                            DisableOrInvalidateItem_ForWhichID(false, nWhich);

                            break;

                        default:

                            assert(!"invalid Argument for eDontCareAs");

                    }

                }

                else

                {

                    // Item is set:

                    PutImpl(*aHit->second, false);

                }

            }

            else

            {

                // Item is default:

                switch (eDefaultAs)

                {

                    case SfxItemState::SET:

                        PutImpl(rSource.GetPool()->GetUserOrPoolDefaultItem(nWhich), false);

                        break;

                    case SfxItemState::DEFAULT:

                        ClearSingleItem_ForWhichID(nWhich);

                        break;

                    case SfxItemState::INVALID:

                        DisableOrInvalidateItem_ForWhichID(false, nWhich);

                        break;

                    default:

                        assert(!"invalid Argument for eDefaultAs");

                }

            }

        }

    }

}

/**

 * Expands the ranges of settable items by 'nFrom' to 'nTo'. Keeps state of

 * items which are new ranges too.

 */

void SfxItemSet::MergeRange( sal_uInt16 nFrom, sal_uInt16 nTo )

{

    // check if all from new range are already included. This will

    // use the cache in WhichRangesContainer since we check linearly.

    // Start with assuming all are included, but only if not empty.

    // If empty all included is wrong (and GetRanges().MergeRange

    // will do the right thing/shortcut)

    bool bAllIncluded(!GetRanges().empty());

    for (sal_uInt16 a(nFrom); bAllIncluded && a <= nTo; a++)

        if (!GetRanges().doesContainWhich(a))

            bAllIncluded = false;

    // if yes, we are done

    if (bAllIncluded)

        return;

    // need to create new WhichRanges

    auto aNewRanges = m_aWhichRanges.MergeRange(nFrom, nTo);

    RecreateRanges_Impl(aNewRanges);

    m_aWhichRanges = std::move(aNewRanges);

}

/**

 * Modifies the ranges of settable items. Keeps state of items which

 * are new ranges too.

 */

void SfxItemSet::SetRanges( const WhichRangesContainer& aNewRanges )

{

    // Identical Ranges?

    if (GetRanges() == aNewRanges)

        return;

    assert(aNewRanges.validRanges2());

    RecreateRanges_Impl(aNewRanges);

    m_aWhichRanges = aNewRanges;

}

void SfxItemSet::SetRanges( WhichRangesContainer&& aNewRanges )

{

    // Identical Ranges?

    if (GetRanges() == aNewRanges)

        return;

    assert(aNewRanges.validRanges2());

    RecreateRanges_Impl(aNewRanges);

    m_aWhichRanges = std::move(aNewRanges);

}

void SfxItemSet::RecreateRanges_Impl(const WhichRangesContainer& rNewRanges)

{

    if (0 == Count())

        // no existing items, done

        return;

    // check if existing items are in the new ItemRanges.

    // if they are not, remove the item

    for (PoolItemMap::iterator aCandidate(m_aPoolItemMap.begin()); aCandidate != m_aPoolItemMap.end();)

    {

        if (!rNewRanges.doesContainWhich(aCandidate->first))

        {

#ifdef DBG_UTIL

            assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet RecreateRanges with active SfxItemIters (!)");

#endif

            ClearSingleItem_PrepareRemove(aCandidate->second);

            aCandidate = m_aPoolItemMap.erase(aCandidate);

        }

        else

            aCandidate++;

    }

}

/**

 * The SfxItemSet takes over exactly those SfxPoolItems that are

 * set in rSet and are in their own Which range. All others are removed.

 * The SfxItemPool is retained, such that SfxPoolItems that have been

 * taken over, are moved from the rSet's SfxItemPool to the SfxItemPool

 * of *this.

 *

 * SfxPoolItems in rSet, for which holds 'IsInvalidItem() == true' are

 * taken over as invalid items.

 *

 * @return bool true

 *              SfxPoolItems have been taken over

 *

 *              false

 *              No SfxPoolItems have been taken over, because

 *              e.g. the Which ranges of SfxItemSets are not intersecting

 *              or the intersection does not contain SfxPoolItems that are

 *              set in rSet

 */

bool SfxItemSet::Set

(

    const SfxItemSet&   rSet,   /*  The SfxItemSet, whose SfxPoolItems are

                                    to been taken over */

    bool                bDeep   /*  true (default)

                                    The SfxPoolItems from the parents that may

                                    be present in rSet, are also taken over into

                                    this SfxPoolItemSet

                                    false

                                    The SfxPoolItems from the parents of

                                    rSet are not taken into account */

)

{

    if (Count())

        ClearItem();

    if (!bDeep)

        return Put(rSet, false);

    bool bRet = false;

    SfxWhichIter aIter1(*this);

    SfxWhichIter aIter2(rSet);

    sal_uInt16 nWhich1 = aIter1.FirstWhich();

    sal_uInt16 nWhich2 = aIter2.FirstWhich();

    for (;;)

    {

        if (!nWhich1 || !nWhich2)

            break;

        if (nWhich1 > nWhich2)

        {

            nWhich2 = aIter2.NextWhich();

            continue;

        }

        if (nWhich1 < nWhich2)

        {

            nWhich1 = aIter1.NextWhich();

            continue;

        }

        const SfxPoolItem* pItem;

        if( SfxItemState::SET == aIter2.GetItemState( true, &pItem ) )

            bRet |= nullptr != Put( *pItem );

        nWhich1 = aIter1.NextWhich();

        nWhich2 = aIter2.NextWhich();

    }

    return bRet;

}

const SfxPoolItem* SfxItemSet::GetItem(sal_uInt16 nId, bool bSearchInParent) const

{

    // evtl. Convert from SlotID to WhichId

    const sal_uInt16 nWhich(GetPool()->GetWhichIDFromSlotID(nId));

    // Is the Item set or 'bDeep == true' available?

    const SfxPoolItem *pItem(nullptr);

    const SfxItemState eState(GetItemState_ForWhichID(SfxItemState::UNKNOWN, nWhich, bSearchInParent, &pItem));

    if (bSearchInParent && SfxItemState::DEFAULT == eState && SfxItemPool::IsWhich(nWhich))

    {

        pItem = &GetPool()->GetUserOrPoolDefaultItem(nWhich);

    }

    return pItem;

}

const SfxPoolItem& SfxItemSet::Get( sal_uInt16 nWhich, bool bSrchInParent) const

{

    if (m_pAccessTracker && !m_bAccessTrackerIgnore) {

        if (std::find(m_pAccessTracker->begin(), m_pAccessTracker->end(), nWhich)

                == m_pAccessTracker->end())

            m_pAccessTracker->push_back(nWhich);

    }

    PoolItemMap::const_iterator aHit(m_aPoolItemMap.find(nWhich));

    if (aHit != m_aPoolItemMap.end())

    {

        if (IsInvalidItem(aHit->second))

        {

            return GetPool()->GetUserOrPoolDefaultItem(nWhich);

        }

#ifdef DBG_UTIL

        if (IsDisabledItem(aHit->second))

            SAL_INFO("svl.items", "SFX_WARNING: Getting disabled Item");

#endif

        return *aHit->second;

    }

    if (bSrchInParent && nullptr != GetParent())

    {

        return GetParent()->Get(nWhich, bSrchInParent);

    }

    // Get the Default from the Pool and return

    assert(m_pPool);

    return GetPool()->GetUserOrPoolDefaultItem(nWhich);

}

/**

 * Notification callback

 */

void SfxItemSet::Changed(const SfxPoolItem*, const SfxPoolItem*) const

{

}

void SfxItemSet::Intersect( const SfxItemSet& rSet )

{

    // Delete all Items *not* contained in rSet

    assert(m_pPool && "Not implemented without Pool");

    if (!Count() || this == &rSet)

        // none set -> none to delete

        // same ItemSet? -> no Items not contained

        return;

    if (!rSet.Count())

    {

        // no Items contained in rSet -> Delete everything

        ClearAllItemsImpl();

        return;

    }

    // locally delete all items *not* contained in rSet, independent of their

    // values, just dependent of existence. Iterate over all existing local items

    for (PoolItemMap::iterator aCandidate(m_aPoolItemMap.begin()); aCandidate != m_aPoolItemMap.end();)

    {

        // check if an item with that WhichID exists in rSet

        const PoolItemMap::const_iterator aHit(rSet.m_aPoolItemMap.find(aCandidate->first));

        if (aHit == rSet.m_aPoolItemMap.end())

        {

            // no item with that WhichID exists in rset, so we have to delete

            // aCandidate.

            // tdf#164712: NOTE: This includes all set items (SfxItemState::SET)

            // but *also* SfxItemState::DISABLED and SfxItemState::INVALID.

#ifdef DBG_UTIL

            assert(0 == m_nRegisteredSfxItemIter && "ITEM: SfxItemSet Intersect with active SfxItemIters (!)");

#endif

            ClearSingleItem_PrepareRemove(aCandidate->second);

            aCandidate = m_aPoolItemMap.erase(aCandidate);

        }

        else

            aCandidate++;

    }

}

void SfxItemSet::Differentiate(const SfxItemSet& rSet)

{

    assert(m_pPool && "Not implemented without Pool");

    // Delete all Items contained in rSet

    if (!Count() || !rSet.Count())

        // None set?

        return;

    if (this == &rSet)

    {

        // same ItemSet, all Items are contained -> Delete everything

        ClearAllItemsImpl();

        return;

    }

    // locally delete all items contained in rSet, independent of their

    // values, just dependent of their existence in rSet.

    // tdf#164712: NOTE: This includes all set items (SfxItemState::SET)

    // but also SfxItemState::DISABLED and SfxItemState::INVALID.

    // These are all items that exist in the std::unordered_map (PoolItemMap)