svl/source/items/stylepool.cxx

   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
  20 #include <svl/stylepool.hxx>
  21 #include <svl/itemiter.hxx>
  22 #include <svl/itempool.hxx>
  23 #include <o3tl/make_unique.hxx>
  24 #include <tools/debug.hxx>
  25 #include <algorithm>
  26 #include <map>
  27 #include <memory>
  28 #include <vector>
  29
  30 namespace {
  31     /** A "Node" represents a subset of inserted SfxItemSets
  32      * The root node represents the empty set
  33      * The other nodes contain a SfxPoolItem and represents an item set which contains their
  34      * pool item and the pool items of their parents.
  35      */
  36     class Node
  37     {
  38         std::vector<std::unique_ptr<Node>> mChildren; // child nodes, create by findChildNode(..)
  39         // container of shared pointers of inserted item sets; for non-poolable
  40         // items more than one item set is needed
  41         std::vector< std::shared_ptr<SfxItemSet> > maItemSet;
  42         std::unique_ptr<const SfxPoolItem> mpItem;   // my pool item
  43         Node *mpUpper;               // if I'm a child node that's my parent node
  44         // #i86923#
  45         const bool mbIsItemIgnorable;
  46     public:
  47         // #i86923#
  48         Node() // root node Ctor
  49             : mChildren(),
  50               maItemSet(),
  51               mpUpper( nullptr ),
  52               mbIsItemIgnorable( false )
  53         {}
  54         Node( const SfxPoolItem& rItem, Node* pParent, const bool bIgnorable ) // child node Ctor
  55             : mChildren(),
  56               maItemSet(),
  57               mpItem( rItem.Clone() ),
  58               mpUpper( pParent ),
  59               mbIsItemIgnorable( bIgnorable )
  60         {}
  61         // #i86923#
  62         bool hasItemSet( const bool bCheckUsage ) const;
  63         // #i87808#
  64         std::shared_ptr<SfxItemSet> const & getItemSet() const
  65         {
  66             return maItemSet.back();
  67         }
  68         std::shared_ptr<SfxItemSet> const & getUsedOrLastAddedItemSet() const;
  69         void setItemSet( const SfxItemSet& rSet ){ maItemSet.push_back( std::shared_ptr<SfxItemSet>( rSet.Clone() ) ); }
  70         // #i86923#
  71         Node* findChildNode( const SfxPoolItem& rItem,
  72                              const bool bIsItemIgnorable );
  73         Node* nextItemSet( Node const * pLast,
  74                            const bool bSkipUnusedItemSet,
  75                            const bool bSkipIgnorable );
  76         // #i86923#
  77         bool hasIgnorableChildren( const bool bCheckUsage ) const;
  78         const std::shared_ptr<SfxItemSet> getItemSetOfIgnorableChild(
  79                                         const bool bSkipUnusedItemSets ) const;
  80     };
  81
  82     // #i87808#
  83     std::shared_ptr<SfxItemSet> const & Node::getUsedOrLastAddedItemSet() const
  84     {
  85         std::vector< std::shared_ptr<SfxItemSet> >::const_reverse_iterator aIter;
  86
  87         for ( aIter = maItemSet.rbegin(); aIter != maItemSet.rend(); ++aIter )
  88         {
  89             if ( (*aIter).use_count() > 1 )
  90             {
  91                 return *aIter;
  92             }
  93         }
  94
  95         return maItemSet.back();
  96     }
  97
  98     // #i86923#
  99     bool Node::hasItemSet( const bool bCheckUsage ) const
 100     {
 101         bool bHasItemSet = false;
 102
 103         if ( !maItemSet.empty())
 104         {
 105             if ( bCheckUsage )
 106             {
 107                 std::vector< std::shared_ptr<SfxItemSet> >::const_reverse_iterator aIter;
 108
 109                 for ( aIter = maItemSet.rbegin(); aIter != maItemSet.rend(); ++aIter )
 110                 {
 111                     if ( (*aIter).use_count() > 1 )
 112                     {
 113                         bHasItemSet = true;
 114                         break;
 115                     }
 116                 }
 117             }
 118             else
 119             {
 120                 bHasItemSet = true;
 121             }
 122         }
 123         return bHasItemSet;
 124     }
 125
 126     // #i86923#
 127     Node* Node::findChildNode( const SfxPoolItem& rItem,
 128                                const bool bIsItemIgnorable )
 129     {
 130         for( auto const & rChild : mChildren )
 131         {
 132             if( rItem.Which() == rChild->mpItem->Which() &&
 133                 rItem == *rChild->mpItem )
 134                 return rChild.get();
 135         }
 136         // #i86923#
 137         auto pNextNode = new Node( rItem, this, bIsItemIgnorable );
 138         mChildren.emplace_back( pNextNode );
 139         return pNextNode;
 140     }
 141
 142     /**
 143      * Find the next node which has a SfxItemSet.
 144      * The input parameter pLast has a sophisticated meaning:
 145      * downstairs only:
 146      * pLast == 0 => scan your children and their children
 147      *               but neither your parents neither your siblings
 148      * downstairs and upstairs:
 149      * pLast == this => scan your children, their children,
 150      *                  the children of your parent behind you, and so on
 151      * partial downstairs and upstairs
 152      *  pLast != 0 && pLast != this => scan your children behind the given children,
 153      *                 the children of your parent behind you and so on.
 154      *
 155      * OD 2008-03-11 #i86923#
 156      * introduce parameters <bSkipUnusedItemSets> and <bSkipIgnorable>
 157      * and its handling.
 158      */
 159     Node* Node::nextItemSet( Node const * pLast,
 160                              const bool bSkipUnusedItemSets,
 161                              const bool bSkipIgnorable )
 162     {
 163         // Searching downstairs
 164         auto aIter = mChildren.begin();
 165         // For pLast == 0 and pLast == this all children are of interest
 166         // for another pLast the search starts behind pLast...
 167         if( pLast && pLast != this )
 168         {
 169             aIter = std::find_if( mChildren.begin(), mChildren.end(),
 170                                   [&] (std::unique_ptr<Node> const &p) { return p.get() == pLast; });
 171             if( aIter != mChildren.end() )
 172                 ++aIter;
 173         }
 174         Node *pNext = nullptr;
 175         while( aIter != mChildren.end() )
 176         {
 177             // #i86923#
 178             if ( bSkipIgnorable && (*aIter)->mbIsItemIgnorable )
 179             {
 180                 ++aIter;
 181                 continue;
 182             }
 183             pNext = aIter->get();
 184             // #i86923#
 185             if ( pNext->hasItemSet( bSkipUnusedItemSets ) )
 186             {
 187                 return pNext;
 188             }
 189             if ( bSkipIgnorable &&
 190                  pNext->hasIgnorableChildren( bSkipUnusedItemSets ) )
 191             {
 192                 return pNext;
 193             }
 194             pNext = pNext->nextItemSet( nullptr, bSkipUnusedItemSets, bSkipIgnorable ); // 0 => downstairs only
 195             if( pNext )
 196                 return pNext;
 197             ++aIter;
 198         }
 199         // Searching upstairs
 200         if( pLast && mpUpper )
 201         {
 202             // #i86923#
 203             pNext = mpUpper->nextItemSet( this, bSkipUnusedItemSets, bSkipIgnorable );
 204         }
 205         return pNext;
 206     }
 207
 208     // #i86923#
 209     bool Node::hasIgnorableChildren( const bool bCheckUsage ) const
 210     {
 211         bool bHasIgnorableChildren( false );
 212
 213         auto aIter = mChildren.begin();
 214         while( aIter != mChildren.end() && !bHasIgnorableChildren )
 215         {
 216             Node* pChild = aIter->get();
 217             if ( pChild->mbIsItemIgnorable )
 218             {
 219                 bHasIgnorableChildren =
 220                     !bCheckUsage ||
 221                     ( pChild->hasItemSet( bCheckUsage /* == true */ ) ||
 222                       pChild->hasIgnorableChildren( bCheckUsage /* == true */ ) );
 223             }
 224             ++aIter;
 225         }
 226
 227         return bHasIgnorableChildren;
 228     }
 229
 230     const std::shared_ptr<SfxItemSet> Node::getItemSetOfIgnorableChild(
 231                                         const bool bSkipUnusedItemSets ) const
 232     {
 233         DBG_ASSERT( hasIgnorableChildren( bSkipUnusedItemSets ),
 234                     "<Node::getItemSetOfIgnorableChild> - node has no ignorable children" );
 235
 236         auto aIter = mChildren.begin();
 237         while( aIter != mChildren.end() )
 238         {
 239             Node* pChild = aIter->get();
 240             if ( pChild->mbIsItemIgnorable )
 241             {
 242                 if ( pChild->hasItemSet( bSkipUnusedItemSets ) )
 243                 {
 244                     return pChild->getUsedOrLastAddedItemSet();
 245                 }
 246                 else
 247                 {
 248                     pChild = pChild->nextItemSet( nullptr, bSkipUnusedItemSets, false );
 249                     if ( pChild )
 250                     {
 251                         return pChild->getUsedOrLastAddedItemSet();
 252                     }
 253                 }
 254             }
 255             ++aIter;
 256         }
 257
 258         std::shared_ptr<SfxItemSet> pReturn;
 259         return pReturn;
 260     }
 261
 262     class Iterator : public IStylePoolIteratorAccess
 263     {
 264         std::map< const SfxItemSet*, Node >& mrRoot;
 265         std::map< const SfxItemSet*, Node >::iterator mpCurrNode;
 266         Node* mpNode;
 267         const bool mbSkipUnusedItemSets;
 268         const bool mbSkipIgnorable;
 269     public:
 270         // #i86923#
 271         Iterator( std::map< const SfxItemSet*, Node >& rR,
 272                   const bool bSkipUnusedItemSets,
 273                   const bool bSkipIgnorable )
 274             : mrRoot( rR ),
 275               mpCurrNode( rR.begin() ),
 276               mpNode(nullptr),
 277               mbSkipUnusedItemSets( bSkipUnusedItemSets ),
 278               mbSkipIgnorable( bSkipIgnorable )
 279         {}
 280         virtual std::shared_ptr<SfxItemSet> getNext() override;
 281     };
 282
 283     std::shared_ptr<SfxItemSet> Iterator::getNext()
 284     {
 285         std::shared_ptr<SfxItemSet> pReturn;
 286         while( mpNode || mpCurrNode != mrRoot.end() )
 287         {
 288             if( !mpNode )
 289             {
 290                 mpNode = &mpCurrNode->second;
 291                 ++mpCurrNode;
 292                 // #i86923#
 293                 if ( mpNode->hasItemSet( mbSkipUnusedItemSets ) )
 294                 {
 295                     // #i87808#
 296                     return mpNode->getUsedOrLastAddedItemSet();
 297                 }
 298             }
 299             // #i86923#
 300             mpNode = mpNode->nextItemSet( mpNode, mbSkipUnusedItemSets, mbSkipIgnorable );
 301             if ( mpNode && mpNode->hasItemSet( mbSkipUnusedItemSets ) )
 302             {
 303                 // #i87808#
 304                 return mpNode->getUsedOrLastAddedItemSet();
 305             }
 306             if ( mbSkipIgnorable &&
 307                  mpNode && mpNode->hasIgnorableChildren( mbSkipUnusedItemSets ) )
 308             {
 309                 return mpNode->getItemSetOfIgnorableChild( mbSkipUnusedItemSets );
 310             }
 311         }
 312         return pReturn;
 313     }
 314
 315 }
 316
 317 /**
 318  * This static method creates a unique name from a shared pointer to a SfxItemSet
 319  * The name is the memory address of the SfxItemSet itself.
 320  */
 321 OUString StylePool::nameOf( const std::shared_ptr<SfxItemSet>& pSet )
 322 {
 323     return OUString::number( reinterpret_cast<sal_IntPtr>( pSet.get() ), 16 );
 324 }
 325
 326 /**
 327  * class StylePoolImpl organized a tree-structure where every node represents a SfxItemSet.
 328  * The insertItemSet method adds a SfxItemSet into the tree if necessary and returns a shared_ptr
 329  * to a copy of the SfxItemSet.
 330  * The aRoot-Node represents an empty SfxItemSet.
 331  */
 332 class StylePoolImpl
 333 {
 334 private:
 335     std::map< const SfxItemSet*, Node > maRoot;
 336     // #i86923#
 337     std::unique_ptr<SfxItemSet> mpIgnorableItems;
 338 #ifdef DEBUG
 339     sal_Int32 mnCount;
 340 #endif
 341 public:
 342     // #i86923#
 343     explicit StylePoolImpl( SfxItemSet const * pIgnorableItems )
 344         : maRoot(),
 345 #ifdef DEBUG
 346           mnCount(0),
 347 #endif
 348           mpIgnorableItems( pIgnorableItems != nullptr
 349                             ? pIgnorableItems->Clone( false )
 350                             : nullptr )
 351     {
 352         DBG_ASSERT( !pIgnorableItems || !pIgnorableItems->Count(),
 353                     "<StylePoolImpl::StylePoolImpl(..)> - misusage: item set for ignorable item should be empty. Please correct usage." );
 354         DBG_ASSERT( !mpIgnorableItems || !mpIgnorableItems->Count(),
 355                     "<StylePoolImpl::StylePoolImpl(..)> - <SfxItemSet::Clone( sal_False )> does not work as excepted - <mpIgnorableItems> is not empty." );
 356     }
 357
 358     std::shared_ptr<SfxItemSet> insertItemSet( const SfxItemSet& rSet );
 359
 360     // #i86923#
 361     std::unique_ptr<IStylePoolIteratorAccess> createIterator( bool bSkipUnusedItemSets,
 362                                               bool bSkipIgnorableItems );
 363 };
 364
 365
 366 std::shared_ptr<SfxItemSet> StylePoolImpl::insertItemSet( const SfxItemSet& rSet )
 367 {
 368     bool bNonPoolable = false;
 369     Node* pCurNode = &maRoot[ rSet.GetParent() ];
 370     SfxItemIter aIter( rSet );
 371     const SfxPoolItem* pItem = aIter.GetCurItem();
 372     // Every SfxPoolItem in the SfxItemSet causes a step deeper into the tree,
 373     // a complete empty SfxItemSet would stay at the root node.
 374     // #i86923# insert ignorable items to the tree leaves.
 375     std::unique_ptr<SfxItemSet> xFoundIgnorableItems;
 376     if ( mpIgnorableItems )
 377     {
 378         xFoundIgnorableItems.reset( new SfxItemSet( *mpIgnorableItems ) );
 379     }
 380     while( pItem )
 381     {
 382         if( !rSet.GetPool()->IsItemPoolable(pItem->Which() ) )
 383             bNonPoolable = true;
 384         if (!xFoundIgnorableItems || (xFoundIgnorableItems->Put(*pItem) == nullptr))
 385         {
 386             pCurNode = pCurNode->findChildNode( *pItem, false );
 387         }
 388         pItem = aIter.NextItem();
 389     }
 390     if ( xFoundIgnorableItems.get() &&
 391          xFoundIgnorableItems->Count() > 0 )
 392     {
 393         SfxItemIter aIgnorableItemsIter( *xFoundIgnorableItems );
 394         pItem = aIgnorableItemsIter.GetCurItem();
 395         while( pItem )
 396         {
 397             if( !rSet.GetPool()->IsItemPoolable(pItem->Which() ) )
 398                 bNonPoolable = true;
 399             pCurNode = pCurNode->findChildNode( *pItem, true );
 400             pItem = aIgnorableItemsIter.NextItem();
 401         }
 402     }
 403     // Every leaf node represents an inserted item set, but "non-leaf" nodes represents subsets
 404     // of inserted itemsets.
 405     // These nodes could have but does not need to have a shared_ptr to a item set.
 406     if( !pCurNode->hasItemSet( false ) )
 407     {
 408         pCurNode->setItemSet( rSet );
 409         bNonPoolable = false; // to avoid a double insertion
 410 #ifdef DEBUG
 411         ++mnCount;
 412 #endif
 413     }
 414     // If rSet contains at least one non poolable item, a new itemset has to be inserted
 415     if( bNonPoolable )
 416         pCurNode->setItemSet( rSet );
 417 #ifdef DEBUG
 418     {
 419         sal_Int32 nCheck = -1;
 420         std::unique_ptr<IStylePoolIteratorAccess> pIter = createIterator(false,false);
 421         std::shared_ptr<SfxItemSet> pTemp;
 422         do
 423         {
 424             ++nCheck;
 425             pTemp = pIter->getNext();
 426         } while( pTemp.get() );
 427         DBG_ASSERT( mnCount == nCheck, "Wrong counting");
 428     }
 429 #endif
 430     return pCurNode->getItemSet();
 431 }
 432
 433 // #i86923#
 434 std::unique_ptr<IStylePoolIteratorAccess> StylePoolImpl::createIterator( bool bSkipUnusedItemSets,
 435                                                          bool bSkipIgnorableItems )
 436 {
 437     return o3tl::make_unique<Iterator>( maRoot, bSkipUnusedItemSets, bSkipIgnorableItems );
 438 }
 439 // Ctor, Dtor and redirected methods of class StylePool, nearly inline ;-)
 440
 441 // #i86923#
 442 StylePool::StylePool( SfxItemSet const * pIgnorableItems )
 443     : pImpl( new StylePoolImpl( pIgnorableItems ) )
 444 {}
 445
 446 std::shared_ptr<SfxItemSet> StylePool::insertItemSet( const SfxItemSet& rSet )
 447 { return pImpl->insertItemSet( rSet ); }
 448
 449 // #i86923#
 450 std::unique_ptr<IStylePoolIteratorAccess> StylePool::createIterator( const bool bSkipUnusedItemSets,
 451                                                      const bool bSkipIgnorableItems )
 452 {
 453     return pImpl->createIterator( bSkipUnusedItemSets, bSkipIgnorableItems );
 454 }
 455
 456 StylePool::~StylePool()
 457 {}
 458
 459 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */