include/svl/itemset.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #pragma once
  20
  21 #include <sal/config.h>
  22
  23 #include <cassert>
  24 #include <cstddef>
  25 #include <memory>
  26 #include <optional>
  27 #include <utility>
  28
  29 #include <svl/svldllapi.h>
  30 #include <svl/poolitem.hxx>
  31 #include <svl/typedwhich.hxx>
  32 #include <svl/whichranges.hxx>
  33
  34 class SfxItemPool;
  35
  36 class SAL_WARN_UNUSED SVL_DLLPUBLIC SfxItemSet
  37 {
  38     friend class SfxItemIter;
  39     friend class SfxWhichIter;
  40
  41     SfxItemPool*      m_pPool;         ///< pool that stores the items
  42     const SfxItemSet* m_pParent;       ///< derivation
  43     SfxPoolItem const** m_ppItems;     ///< pointer to array of items, we allocate and free this unless m_bItemsFixed==true
  44     WhichRangesContainer m_pWhichRanges;  ///< array of Which Ranges
  45     sal_uInt16        m_nCount;        ///< number of items
  46     bool              m_bItemsFixed; ///< true if this is a SfxItemSetFixed object
  47
  48 friend class SfxItemPoolCache;
  49 friend class SfxAllItemSet;
  50
  51 private:
  52     SVL_DLLPRIVATE void       RecreateRanges_Impl(const WhichRangesContainer& pNewRanges);
  53
  54 public:
  55     SfxPoolItem const**         GetItems_Impl() const { return m_ppItems; }
  56
  57 private:
  58     const SfxItemSet&           operator=(const SfxItemSet &) = delete;
  59
  60 protected:
  61     // Notification-Callback
  62     virtual void                Changed( const SfxPoolItem& rOld, const SfxPoolItem& rNew );
  63
  64     void                        PutDirect(const SfxPoolItem &rItem);
  65
  66     virtual const SfxPoolItem*  PutImpl( const SfxPoolItem&, sal_uInt16 nWhich, bool bPassingOwnership );
  67
  68     /** special constructor for SfxAllItemSet */
  69     enum class SfxAllItemSetFlag { Flag };
  70     SfxItemSet( SfxItemPool&, SfxAllItemSetFlag );
  71     /** special constructor for SfxItemSetFixed */
  72     SfxItemSet( SfxItemPool&, WhichRangesContainer&& ranges, SfxPoolItem const ** ppItems );
  73
  74 public:
  75     SfxItemSet( const SfxItemSet& );
  76     SfxItemSet( SfxItemSet&& ) noexcept;
  77     SfxItemSet( SfxItemPool& );
  78     SfxItemSet( SfxItemPool&, WhichRangesContainer ranges );
  79
  80     SfxItemSet( SfxItemPool& rPool, sal_uInt16 nWhichStart, sal_uInt16 nWhichEnd )
  81         : SfxItemSet(rPool, WhichRangesContainer(nWhichStart, nWhichEnd)) {}
  82
  83     template<sal_uInt16... WIDs>
  84     SfxItemSet(SfxItemPool& pool, svl::Items_t<WIDs...> wids)
  85         : SfxItemSet(pool, WhichRangesContainer(wids)) {}
  86
  87     virtual ~SfxItemSet();
  88
  89     virtual std::unique_ptr<SfxItemSet> Clone(bool bItems = true, SfxItemPool *pToPool = nullptr) const;
  90     /** note that this only works if you know for sure that you are dealing with an SfxItemSet
  91         and not one of it's subclasses. */
  92     SfxItemSet CloneAsValue(bool bItems = true, SfxItemPool *pToPool = nullptr) const;
  93
  94     // Get number of items
  95     sal_uInt16                  Count() const { return m_nCount; }
  96     sal_uInt16                  TotalCount() const;
  97
  98     const SfxPoolItem&          Get( sal_uInt16 nWhich, bool bSrchInParent = true ) const;
  99     template<class T>
 100     const T&                    Get( TypedWhichId<T> nWhich, bool bSrchInParent = true ) const
 101     {
 102         return static_cast<const T&>(Get(sal_uInt16(nWhich), bSrchInParent));
 103     }
 104
 105     /** This method eases accessing single Items in the SfxItemSet.
 106
 107         @param nId SlotId or the Item's WhichId
 108         @param bSearchInParent also search in parent ItemSets
 109         @returns 0 if the ItemSet does not contain an Item with the Id 'nWhich'
 110     */
 111     const SfxPoolItem*          GetItem(sal_uInt16 nWhich, bool bSearchInParent = true) const;
 112
 113     /// Templatized version of GetItem() to directly return the correct type.
 114     template<class T> const T* GetItem(sal_uInt16 nWhich, bool bSearchInParent = true) const
 115     {
 116         const SfxPoolItem* pItem = GetItem(nWhich, bSearchInParent);
 117         const T* pCastedItem = dynamic_cast<const T*>(pItem);
 118
 119         assert(!pItem || pCastedItem); // if it exists, must have the correct type
 120         return pCastedItem;
 121     }
 122     template<class T> const T* GetItem( TypedWhichId<T> nWhich, bool bSearchInParent = true ) const
 123     {
 124         return GetItem<T>(sal_uInt16(nWhich), bSearchInParent);
 125     }
 126
 127
 128     /// Templatized static version of GetItem() to directly return the correct type if the SfxItemSet is available.
 129     template<class T> static const T* GetItem(const SfxItemSet* pItemSet, sal_uInt16 nWhich, bool bSearchInParent)
 130     {
 131         if (pItemSet)
 132             return pItemSet->GetItem<T>(nWhich, bSearchInParent);
 133
 134         return nullptr;
 135     }
 136     template <class T>
 137     static const T* GetItem(const SfxItemSet* pItemSet, TypedWhichId<T> nWhich,
 138                             bool bSearchInParent)
 139     {
 140         return GetItem<T>(pItemSet, static_cast<sal_uInt16>(nWhich), bSearchInParent);
 141     }
 142
 143     sal_uInt16                  GetWhichByPos(sal_uInt16 nPos) const;
 144
 145     SfxItemState                GetItemState(   sal_uInt16 nWhich,
 146                                                 bool bSrchInParent = true,
 147                                                 const SfxPoolItem **ppItem = nullptr ) const;
 148
 149     template <class T>
 150     SfxItemState                GetItemState(   TypedWhichId<T> nWhich,
 151                                                 bool bSrchInParent = true,
 152                                                 const T **ppItem = nullptr ) const
 153     { return GetItemState(sal_uInt16(nWhich), bSrchInParent, reinterpret_cast<SfxPoolItem const**>(ppItem)); }
 154
 155     /// Templatized version of GetItemState() to directly return the correct type.
 156     template<class T>
 157     const T *                   GetItemIfSet(   TypedWhichId<T> nWhich,
 158                                                 bool bSrchInParent = true ) const
 159     {
 160         const SfxPoolItem * pItem = nullptr;
 161         if( SfxItemState::SET == GetItemState(sal_uInt16(nWhich), bSrchInParent, &pItem) )
 162             return static_cast<const T*>(pItem);
 163         return nullptr;
 164     }
 165
 166     bool                        HasItem(sal_uInt16 nWhich, const SfxPoolItem** ppItem = nullptr) const;
 167     template<class T>
 168     bool                        HasItem(TypedWhichId<T> nWhich, const T** ppItem = nullptr) const
 169     { return HasItem(sal_uInt16(nWhich), reinterpret_cast<const SfxPoolItem**>(ppItem)); }
 170
 171     void                        DisableItem(sal_uInt16 nWhich);
 172     void                        InvalidateItem( sal_uInt16 nWhich );
 173     sal_uInt16                  ClearItem( sal_uInt16 nWhich = 0);
 174     void                        ClearInvalidItems();
 175     void                        InvalidateAllItems(); // HACK(via nWhich = 0) ???
 176
 177     inline void                 SetParent( const SfxItemSet* pNew );
 178
 179     // add, delete items, work on items
 180 public:
 181     const SfxPoolItem*          Put( const SfxPoolItem& rItem, sal_uInt16 nWhich )
 182     { return PutImpl(rItem, nWhich, /*bPassingOwnership*/false); }
 183     const SfxPoolItem*          Put( std::unique_ptr<SfxPoolItem> xItem, sal_uInt16 nWhich )
 184     { return PutImpl(*xItem.release(), nWhich, /*bPassingOwnership*/true); }
 185     const SfxPoolItem*          Put( const SfxPoolItem& rItem )
 186                                 { return Put(rItem, rItem.Which()); }
 187     const SfxPoolItem*          Put( std::unique_ptr<SfxPoolItem> xItem )
 188                                 { auto nWhich = xItem->Which(); return Put(std::move(xItem), nWhich); }
 189     bool                        Put( const SfxItemSet&,
 190                                      bool bInvalidAsDefault = true );
 191     void                        PutExtended( const SfxItemSet&,
 192                                              SfxItemState eDontCareAs,
 193                                              SfxItemState eDefaultAs );
 194
 195     bool                        Set( const SfxItemSet&, bool bDeep = true );
 196
 197     void                        Intersect( const SfxItemSet& rSet );
 198     void                        MergeValues( const SfxItemSet& rSet );
 199     void                        Differentiate( const SfxItemSet& rSet );
 200     void                        MergeValue( const SfxPoolItem& rItem, bool bOverwriteDefaults = false  );
 201
 202     SfxItemPool*                GetPool() const { return m_pPool; }
 203     const WhichRangesContainer & GetRanges() const { return m_pWhichRanges; }
 204     void                        SetRanges( const WhichRangesContainer& );
 205     void                        SetRanges( WhichRangesContainer&& );
 206     void                        MergeRange( sal_uInt16 nFrom, sal_uInt16 nTo );
 207     const SfxItemSet*           GetParent() const { return m_pParent; }
 208
 209     bool                        operator==(const SfxItemSet &) const;
 210
 211     /** Compare possibly ignoring SfxItemPool pointer.
 212
 213         This can be used to compare the content of two SfxItemSet even if they
 214         don't share the same pool. EditTextObject::Equals(...,false) uses this
 215         which is needed in ScGlobal::EETextObjEqual() for
 216         ScPageHFItem::operator==()
 217
 218         @param  bComparePool
 219                 if <FALSE/> ignore SfxItemPool pointer,
 220                 if <TRUE/> compare also SfxItemPool pointer (identical to operator==())
 221      */
 222     bool                        Equals(const SfxItemSet &, bool bComparePool) const;
 223
 224     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 225
 226 private:
 227     sal_uInt16 ClearSingleItemImpl( sal_uInt16 nWhich, std::optional<sal_uInt16> oItemOffsetHint );
 228     sal_uInt16 ClearAllItemsImpl();
 229     SfxItemState  GetItemStateImpl( sal_uInt16 nWhich,
 230                                 bool bSrchInParent,
 231                                 const SfxPoolItem **ppItem,
 232                                 std::optional<sal_uInt16> oItemsOffsetHint) const;
 233 };
 234
 235 inline void SfxItemSet::SetParent( const SfxItemSet* pNew )
 236 {
 237     m_pParent = pNew;
 238 }
 239
 240 class SVL_DLLPUBLIC SfxAllItemSet final : public SfxItemSet
 241
 242 //  Handles all Ranges. Ranges are automatically modified by putting items.
 243
 244 {
 245 public:
 246                                 SfxAllItemSet( SfxItemPool &rPool );
 247                                 SfxAllItemSet( const SfxItemSet & );
 248                                 SfxAllItemSet( const SfxAllItemSet & );
 249
 250     virtual std::unique_ptr<SfxItemSet> Clone( bool bItems = true, SfxItemPool *pToPool = nullptr ) const override;
 251 private:
 252     virtual const SfxPoolItem*  PutImpl( const SfxPoolItem&, sal_uInt16 nWhich, bool bPassingOwnership ) override;
 253 };
 254
 255
 256 namespace svl::detail
 257 {
 258 /**
 259  * Determines the number of sal_uInt16s in a container of pairs of
 260  * sal_uInt16s, each representing a range of sal_uInt16s, and total capacity of the ranges.
 261  */
 262 template <sal_uInt16 WID1, sal_uInt16 WID2, sal_uInt16... Rest>
 263 static constexpr sal_uInt16 CountRanges1()
 264 {
 265     sal_uInt16 nCapacity = rangeSize(WID1, WID2);
 266     if constexpr (sizeof...(Rest) > 0)
 267         nCapacity += CountRanges1<Rest...>();
 268     return nCapacity;
 269 }}
 270
 271 // Allocate the items array inside the object, to reduce allocation cost.
 272 //
 273 template<sal_uInt16... WIDs>
 274 class SfxItemSetFixed : public SfxItemSet
 275 {
 276 public:
 277     SfxItemSetFixed( SfxItemPool& rPool)
 278         : SfxItemSet(rPool, WhichRangesContainer(svl::Items_t<WIDs...>{}), m_aItems) {}
 279 private:
 280     static constexpr sal_uInt16 NITEMS = svl::detail::CountRanges1<WIDs...>();
 281     const SfxPoolItem* m_aItems[NITEMS] = {};
 282 };
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */