basegfx/source/tools/systemdependentdata.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 <basegfx/utils/systemdependentdata.hxx>
  11 #include <math.h>
  12
  13 namespace basegfx
  14 {
  15     SystemDependentDataManager::SystemDependentDataManager()
  16     {
  17     }
  18
  19     SystemDependentDataManager::~SystemDependentDataManager()
  20     {
  21     }
  22 } // namespace basegfx
  23
  24 namespace basegfx
  25 {
  26     MinimalSystemDependentDataManager::MinimalSystemDependentDataManager()
  27     :   SystemDependentDataManager(),
  28         maSystemDependentDataReferences()
  29     {
  30     }
  31
  32     MinimalSystemDependentDataManager::~MinimalSystemDependentDataManager()
  33     {
  34     }
  35
  36     void MinimalSystemDependentDataManager::startUsage(basegfx::SystemDependentData_SharedPtr& rData)
  37     {
  38         if(rData)
  39         {
  40             maSystemDependentDataReferences.insert(rData);
  41         }
  42     }
  43
  44     void MinimalSystemDependentDataManager::endUsage(basegfx::SystemDependentData_SharedPtr& rData)
  45     {
  46         if(rData)
  47         {
  48             maSystemDependentDataReferences.erase(rData);
  49         }
  50     }
  51
  52     void MinimalSystemDependentDataManager::touchUsage(basegfx::SystemDependentData_SharedPtr& /* rData */)
  53     {
  54     }
  55
  56     void MinimalSystemDependentDataManager::flushAll()
  57     {
  58         maSystemDependentDataReferences.clear();
  59     }
  60 } // namespace basegfx
  61
  62 namespace basegfx
  63 {
  64     SystemDependentData::SystemDependentData(
  65         SystemDependentDataManager& rSystemDependentDataManager)
  66     :   mrSystemDependentDataManager(rSystemDependentDataManager),
  67         mnCalculatedCycles(0)
  68     {
  69     }
  70
  71     SystemDependentData::~SystemDependentData()
  72     {
  73     }
  74
  75     sal_uInt32 SystemDependentData::calculateCombinedHoldCyclesInSeconds() const
  76     {
  77         if(0 == mnCalculatedCycles)
  78         {
  79             const sal_Int64 nBytes(estimateUsageInBytes());
  80             const sal_uInt32 nSeconds = 60; // HoldCyclesInSeconds
  81
  82             // default is Seconds (minimal is one)
  83             sal_uInt32 nResult(0 == nSeconds ? 1 : nSeconds);
  84
  85             if(0 != nBytes)
  86             {
  87                 // use sqrt to get some curved shape. With a default of 60s we get
  88                 // a single second at 3600 byte. To get close to 10mb, multiply by
  89                 // a corresponding scaling factor
  90                 const double fScaleToMB(3600.0 / (1024.0 * 1024.0 * 10.0));
  91
  92                 // also use a multiplier to move the start point higher
  93                 const double fMultiplierSeconds(10.0);
  94
  95                 // calculate
  96                 nResult = static_cast<sal_uInt32>((fMultiplierSeconds * nSeconds) / sqrt(nBytes * fScaleToMB));
  97
  98                 // minimal value is 1
  99                 if(nResult < 1)
 100                 {
 101                     nResult = 1;
 102                 }
 103
 104                 // maximal value is nSeconds
 105                 if(nResult > nSeconds)
 106                 {
 107                     nResult = nSeconds;
 108                 }
 109             }
 110
 111             // set locally (once, on-demand created, non-zero)
 112             const_cast<SystemDependentData*>(this)->mnCalculatedCycles = nResult;
 113         }
 114
 115         return mnCalculatedCycles;
 116     }
 117
 118     sal_Int64 SystemDependentData::estimateUsageInBytes() const
 119     {
 120         // default implementation has no idea
 121         return 0;
 122     }
 123 } // namespace basegfx
 124
 125 namespace basegfx
 126 {
 127     SystemDependentDataHolder::SystemDependentDataHolder()
 128     :   maSystemDependentReferences()
 129     {
 130     }
 131
 132     SystemDependentDataHolder::~SystemDependentDataHolder()
 133     {
 134         for(const auto& candidate : maSystemDependentReferences)
 135         {
 136             basegfx::SystemDependentData_SharedPtr aData(candidate.second.lock());
 137
 138             if(aData)
 139             {
 140                 aData->getSystemDependentDataManager().endUsage(aData);
 141             }
 142         }
 143     }
 144
 145     void SystemDependentDataHolder::addOrReplaceSystemDependentData(basegfx::SystemDependentData_SharedPtr& rData)
 146     {
 147         const size_t hash_code(typeid(*rData).hash_code());
 148         auto result(maSystemDependentReferences.find(hash_code));
 149
 150         if(result != maSystemDependentReferences.end())
 151         {
 152             basegfx::SystemDependentData_SharedPtr aData(result->second.lock());
 153
 154             if(aData)
 155             {
 156                 aData->getSystemDependentDataManager().endUsage(aData);
 157             }
 158
 159             maSystemDependentReferences.erase(result);
 160             result = maSystemDependentReferences.end();
 161         }
 162
 163         maSystemDependentReferences[hash_code] = rData;
 164         rData->getSystemDependentDataManager().startUsage(rData);
 165     }
 166
 167     SystemDependentData_SharedPtr SystemDependentDataHolder::getSystemDependentData(size_t hash_code) const
 168     {
 169         basegfx::SystemDependentData_SharedPtr aRetval;
 170         auto result(maSystemDependentReferences.find(hash_code));
 171
 172         if(result != maSystemDependentReferences.end())
 173         {
 174             aRetval = result->second.lock();
 175
 176             if(aRetval)
 177             {
 178                 aRetval->getSystemDependentDataManager().touchUsage(aRetval);
 179             }
 180             else
 181             {
 182                 const_cast< SystemDependentDataHolder* >(this)->maSystemDependentReferences.erase(result);
 183             }
 184         }
 185
 186         return aRetval;
 187     }
 188 } // namespace basegfx
 189
 190 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */