summaryrefslogtreecommitdiffstats
path: root/include/svl/itempool.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /include/svl/itempool.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'include/svl/itempool.hxx')
-rw-r--r--include/svl/itempool.hxx228
1 files changed, 228 insertions, 0 deletions
diff --git a/include/svl/itempool.hxx b/include/svl/itempool.hxx
new file mode 100644
index 000000000..e85451ecb
--- /dev/null
+++ b/include/svl/itempool.hxx
@@ -0,0 +1,228 @@
+/* -*- 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 <rtl/ref.hxx>
+#include <svl/poolitem.hxx>
+#include <svl/svldllapi.h>
+#include <svl/typedwhich.hxx>
+#include <svl/whichranges.hxx>
+#include <memory>
+#include <vector>
+#include <o3tl/sorted_vector.hxx>
+#include <salhelper/simplereferenceobject.hxx>
+
+class SfxBroadcaster;
+struct SfxItemPool_Impl;
+
+struct SfxItemInfo
+{
+ sal_uInt16 _nSID;
+ bool _bPoolable;
+};
+
+class SfxItemPool;
+
+/** Base class for providers of defaults of SfxPoolItems.
+ *
+ * The derived classes hold the concrete (const) instances which are referenced in several places
+ * (usually within a single document).
+ * This helps to lower the amount of calls to lifecycle methods, speeds up comparisons within a document
+ * and facilitates loading and saving of attributes.
+ */
+class SVL_DLLPUBLIC SfxItemPool : public salhelper::SimpleReferenceObject
+{
+ friend struct SfxItemPool_Impl;
+ friend class SfxItemSet;
+ friend class SfxAllItemSet;
+
+ const SfxItemInfo* pItemInfos;
+ std::unique_ptr<SfxItemPool_Impl> pImpl;
+
+private:
+ sal_uInt16 GetIndex_Impl(sal_uInt16 nWhich) const;
+ sal_uInt16 GetSize_Impl() const;
+
+ SVL_DLLPRIVATE bool IsItemPoolable_Impl( sal_uInt16 nWhich ) const;
+
+public:
+ // for default SfxItemSet::CTOR, set default WhichRanges
+ void FillItemIdRanges_Impl( WhichRangesContainer& pWhichRanges ) const;
+ const WhichRangesContainer & GetFrozenIdRanges() const;
+
+protected:
+ static inline void ClearRefCount(SfxPoolItem& rItem);
+ static inline void AddRef(const SfxPoolItem& rItem);
+ static inline sal_uInt32 ReleaseRef(const SfxPoolItem& rItem, sal_uInt32 n = 1);
+
+public:
+ SfxItemPool( const SfxItemPool &rPool,
+ bool bCloneStaticDefaults = false );
+ SfxItemPool( const OUString &rName,
+ sal_uInt16 nStart, sal_uInt16 nEnd,
+ const SfxItemInfo *pItemInfos,
+ std::vector<SfxPoolItem*> *pDefaults = nullptr );
+
+public:
+ virtual ~SfxItemPool();
+
+ SfxBroadcaster& BC();
+
+ void SetPoolDefaultItem( const SfxPoolItem& );
+
+ const SfxPoolItem* GetPoolDefaultItem( sal_uInt16 nWhich ) const;
+ template<class T> const T* GetPoolDefaultItem( TypedWhichId<T> nWhich ) const
+ { return static_cast<const T*>(GetPoolDefaultItem(sal_uInt16(nWhich))); }
+
+ void ResetPoolDefaultItem( sal_uInt16 nWhich );
+
+ void SetDefaults(std::vector<SfxPoolItem*>* pDefaults);
+ void ClearDefaults();
+ void ReleaseDefaults( bool bDelete = false );
+ static void ReleaseDefaults( std::vector<SfxPoolItem*> *pDefaults, bool bDelete = false );
+
+ virtual MapUnit GetMetric( sal_uInt16 nWhich ) const;
+ void SetDefaultMetric( MapUnit eNewMetric );
+ MapUnit GetDefaultMetric() const;
+
+ /** Request string representation of pool items.
+
+ This virtual function produces a string representation
+ from the respective SfxItemPool subclass' known SfxPoolItems.
+
+ Subclasses, please override this method, and handle
+ SfxPoolItems that don't return useful/complete information on
+ SfxPoolItem::GetPresentation()
+
+ This baseclass yields the unmodified string representation of
+ rItem.
+
+ @param[in] rItem
+ SfxPoolItem to query the string representation of
+
+ @param[in] ePresent
+ requested kind of representation - see SfxItemPresentation
+
+ @param[in] eMetric
+ requested unit of measure of the representation
+
+ @param[out] rText
+ string representation of 'rItem'
+
+ @return true if it has a valid string representation
+ */
+ virtual bool GetPresentation( const SfxPoolItem& rItem,
+ MapUnit ePresentationMetric,
+ OUString& rText,
+ const IntlWrapper& rIntlWrapper ) const;
+ virtual rtl::Reference<SfxItemPool> Clone() const;
+ const OUString& GetName() const;
+
+ template<class T> const T& Put( std::unique_ptr<T> xItem, sal_uInt16 nWhich = 0 )
+ { return static_cast<const T&>(PutImpl( *xItem.release(), nWhich, /*bPassingOwnership*/true)); }
+ template<class T> const T& Put( const T& rItem, sal_uInt16 nWhich = 0 )
+ { return static_cast<const T&>(PutImpl( rItem, nWhich, /*bPassingOwnership*/false)); }
+ void Remove( const SfxPoolItem& );
+
+ const SfxPoolItem& GetDefaultItem( sal_uInt16 nWhich ) const;
+ template<class T> const T& GetDefaultItem( TypedWhichId<T> nWhich ) const
+ { return static_cast<const T&>(GetDefaultItem(sal_uInt16(nWhich))); }
+
+ bool CheckItemInPool(const SfxPoolItem *) const;
+
+ struct Item2Range
+ {
+ o3tl::sorted_vector<SfxPoolItem*>::const_iterator m_begin;
+ o3tl::sorted_vector<SfxPoolItem*>::const_iterator m_end;
+ o3tl::sorted_vector<SfxPoolItem*>::const_iterator const & begin() const { return m_begin; }
+ o3tl::sorted_vector<SfxPoolItem*>::const_iterator const & end() const { return m_end; }
+ };
+ const SfxPoolItem * GetItem2Default(sal_uInt16 nWhich) const;
+ template<class T> const T* GetItem2Default( TypedWhichId<T> nWhich ) const
+ { return static_cast<const T*>(GetItem2Default(sal_uInt16(nWhich))); }
+
+ sal_uInt32 GetItemCount2(sal_uInt16 nWhich) const;
+ Item2Range GetItemSurrogates(sal_uInt16 nWhich) const;
+ /*
+ This is only valid for SfxPoolItem that override IsSortable and operator<.
+ Returns a range of items defined by using operator<.
+ @param rNeedle must be the same type or a supertype of the pool items for nWhich.
+ */
+ std::vector<const SfxPoolItem*> FindItemSurrogate(sal_uInt16 nWhich, SfxPoolItem const & rNeedle) const;
+
+ sal_uInt16 GetFirstWhich() const;
+ sal_uInt16 GetLastWhich() const;
+ bool IsInRange( sal_uInt16 nWhich ) const;
+ void SetSecondaryPool( SfxItemPool *pPool );
+ SfxItemPool* GetSecondaryPool() const;
+ /* get the last pool by following the GetSecondaryPool chain */
+ SfxItemPool* GetLastPoolInChain();
+ SfxItemPool* GetMasterPool() const;
+ void FreezeIdRanges();
+
+ void Delete();
+
+ bool IsItemPoolable( sal_uInt16 nWhich ) const;
+ bool IsItemPoolable( const SfxPoolItem &rItem ) const
+ { return IsItemPoolable( rItem.Which() ); }
+ void SetItemInfos( const SfxItemInfo *pInfos );
+ sal_uInt16 GetWhich( sal_uInt16 nSlot, bool bDeep = true ) const;
+ template<class T>
+ TypedWhichId<T> GetWhich( TypedWhichId<T> nSlot, bool bDeep = true ) const
+ { return TypedWhichId<T>(GetWhich(sal_uInt16(nSlot), bDeep)); }
+ sal_uInt16 GetSlotId( sal_uInt16 nWhich ) const;
+ sal_uInt16 GetTrueWhich( sal_uInt16 nSlot, bool bDeep = true ) const;
+ sal_uInt16 GetTrueSlotId( sal_uInt16 nWhich ) const;
+
+ static bool IsWhich(sal_uInt16 nId) {
+ return nId && nId <= SFX_WHICH_MAX; }
+ static bool IsSlot(sal_uInt16 nId) {
+ return nId && nId > SFX_WHICH_MAX; }
+
+ void dumpAsXml(xmlTextWriterPtr pWriter) const;
+
+protected:
+ virtual const SfxPoolItem& PutImpl( const SfxPoolItem&, sal_uInt16 nWhich = 0, bool bPassingOwnership = false );
+private:
+ const SfxItemPool& operator=(const SfxItemPool &) = delete;
+
+ //IDs below or equal are Which IDs, IDs above slot IDs
+ static const sal_uInt16 SFX_WHICH_MAX = 4999;
+};
+
+// only the pool may manipulate the reference counts
+inline void SfxItemPool::ClearRefCount(SfxPoolItem& rItem)
+{
+ rItem.SetRefCount(0);
+}
+
+// only the pool may manipulate the reference counts
+inline void SfxItemPool::AddRef(const SfxPoolItem& rItem)
+{
+ rItem.AddRef();
+}
+
+// only the pool may manipulate the reference counts
+inline sal_uInt32 SfxItemPool::ReleaseRef(const SfxPoolItem& rItem, sal_uInt32 n)
+{
+ return rItem.ReleaseRef(n);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */