svl/source/misc/sharedstringpool.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
  10 #include <svl/sharedstringpool.hxx>
  11 #include <svl/sharedstring.hxx>
  12 #include <unotools/charclass.hxx>
  13 #include <osl/mutex.hxx>
  14
  15 #include <unordered_map>
  16 #include <unordered_set>
  17
  18 namespace svl
  19 {
  20 namespace
  21 {
  22 sal_Int32 getRefCount(const rtl_uString* p) { return (p->refCount & 0x3FFFFFFF); }
  23 }
  24
  25 struct SharedStringPool::Impl
  26 {
  27     mutable osl::Mutex maMutex;
  28     // We use this map for two purposes - to store lower->upper case mappings
  29     // and to retrieve a shared uppercase object, so the management logic
  30     // is quite complex.
  31     std::unordered_map<OUString, OUString> maStrMap;
  32     const CharClass& mrCharClass;
  33
  34     explicit Impl(const CharClass& rCharClass)
  35         : mrCharClass(rCharClass)
  36     {
  37     }
  38 };
  39
  40 SharedStringPool::SharedStringPool(const CharClass& rCharClass)
  41     : mpImpl(new Impl(rCharClass))
  42 {
  43 }
  44
  45 SharedStringPool::~SharedStringPool() {}
  46
  47 SharedString SharedStringPool::intern(const OUString& rStr)
  48 {
  49     osl::MutexGuard aGuard(&mpImpl->maMutex);
  50
  51     auto[mapIt, bInserted] = mpImpl->maStrMap.emplace(rStr, rStr);
  52     if (!bInserted)
  53         // there is already a mapping
  54         return SharedString(mapIt->first.pData, mapIt->second.pData);
  55
  56     // This is a new string insertion. Establish mapping to upper-case variant.
  57     OUString aUpper = mpImpl->mrCharClass.uppercase(rStr);
  58     if (aUpper == rStr)
  59         // no need to do anything more, because we inserted an upper->upper mapping
  60         return SharedString(mapIt->first.pData, mapIt->second.pData);
  61
  62     // We need to insert a lower->upper mapping, so also insert
  63     // an upper->upper mapping, which we can use both for when an upper string
  64     // is interned, and to look up a shared upper string.
  65     auto mapIt2 = mpImpl->maStrMap.find(aUpper);
  66     if (mapIt2 != mpImpl->maStrMap.end())
  67     {
  68         // there is an already existing upper string
  69         mapIt->second = mapIt2->first;
  70         return SharedString(mapIt->first.pData, mapIt->second.pData);
  71     }
  72
  73     // There is no already existing upper string.
  74     // First, update using the iterator, can't do this later because
  75     // the iterator will be invalid.
  76     mapIt->second = aUpper;
  77     mpImpl->maStrMap.emplace_hint(mapIt2, aUpper, aUpper);
  78     return SharedString(rStr.pData, aUpper.pData);
  79 }
  80
  81 void SharedStringPool::purge()
  82 {
  83     osl::MutexGuard aGuard(&mpImpl->maMutex);
  84
  85     // Because we can have an uppercase entry mapped to itself,
  86     // and then a bunch of lowercase entries mapped to that same
  87     // upper-case entry, we need to scan the map twice - the first
  88     // time to remove lowercase entries, and then only can we
  89     // check for unused uppercase entries.
  90
  91     auto it = mpImpl->maStrMap.begin();
  92     auto itEnd = mpImpl->maStrMap.end();
  93     while (it != itEnd)
  94     {
  95         rtl_uString* p1 = it->first.pData;
  96         rtl_uString* p2 = it->second.pData;
  97         if (p1 != p2)
  98         {
  99             // normal case - lowercase mapped to uppercase, which
 100             // means that the lowercase entry has one ref-counted
 101             // entry as the key in the map
 102             if (getRefCount(p1) == 1)
 103             {
 104                 it = mpImpl->maStrMap.erase(it);
 105                 continue;
 106             }
 107         }
 108         ++it;
 109     }
 110
 111     it = mpImpl->maStrMap.begin();
 112     itEnd = mpImpl->maStrMap.end();
 113     while (it != itEnd)
 114     {
 115         rtl_uString* p1 = it->first.pData;
 116         rtl_uString* p2 = it->second.pData;
 117         if (p1 == p2)
 118         {
 119             // uppercase which is mapped to itself, which means
 120             // one ref-counted entry as the key in the map, and
 121             // one ref-counted entry in the value in the map
 122             if (getRefCount(p1) == 2)
 123             {
 124                 it = mpImpl->maStrMap.erase(it);
 125                 continue;
 126             }
 127         }
 128         ++it;
 129     }
 130 }
 131
 132 size_t SharedStringPool::getCount() const
 133 {
 134     osl::MutexGuard aGuard(&mpImpl->maMutex);
 135     return mpImpl->maStrMap.size();
 136 }
 137
 138 size_t SharedStringPool::getCountIgnoreCase() const
 139 {
 140     osl::MutexGuard aGuard(&mpImpl->maMutex);
 141     // this is only called from unit tests, so no need to be efficient
 142     std::unordered_set<OUString> aUpperSet;
 143     for (auto const& pair : mpImpl->maStrMap)
 144         aUpperSet.insert(pair.second);
 145     return aUpperSet.size();
 146 }
 147 }
 148
 149 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */