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     SystemDependentData::SystemDependentData(
  27         SystemDependentDataManager& rSystemDependentDataManager)
  28     :   mrSystemDependentDataManager(rSystemDependentDataManager),
  29         mnCalculatedCycles(0)
  30     {
  31     }
  32
  33     SystemDependentData::~SystemDependentData()
  34     {
  35     }
  36
  37     sal_uInt32 SystemDependentData::calculateCombinedHoldCyclesInSeconds() const
  38     {
  39         if(0 == mnCalculatedCycles)
  40         {
  41             const sal_Int64 nBytes(estimateUsageInBytes());
  42
  43             // tdf#129845 as indicator for no need to buffer trivial data, stay at and
  44             // return zero. As border, use 450 bytes. For polygons, this means to buffer
  45             // starting with ca. 50 points (GDIPLUS uses 9 bytes per coordinate). For
  46             // Bitmap data this means to more or less always buffer (as it was before).
  47             // For the future, a more sophisticated differentiation may be added
  48             if(nBytes > 450)
  49             {
  50                 const sal_uInt32 nSeconds = 60; // HoldCyclesInSeconds
  51
  52                 // default is Seconds (minimal is one)
  53                 sal_uInt32 nResult(0 == nSeconds ? 1 : nSeconds);
  54
  55                 if(0 != nBytes)
  56                 {
  57                     // use sqrt to get some curved shape. With a default of 60s we get
  58                     // a single second at 3600 byte. To get close to 10mb, multiply by
  59                     // a corresponding scaling factor
  60                     const double fScaleToMB(3600.0 / (1024.0 * 1024.0 * 10.0));
  61
  62                     // also use a multiplier to move the start point higher
  63                     const double fMultiplierSeconds(10.0);
  64
  65                     // calculate
  66                     nResult = static_cast<sal_uInt32>((fMultiplierSeconds * nSeconds) / sqrt(nBytes * fScaleToMB));
  67
  68                     // minimal value is 1
  69                     if(nResult < 1)
  70                     {
  71                         nResult = 1;
  72                     }
  73
  74                     // maximal value is nSeconds
  75                     if(nResult > nSeconds)
  76                     {
  77                         nResult = nSeconds;
  78                     }
  79                 }
  80
  81                 // set locally (once, on-demand created, non-zero)
  82                 const_cast<SystemDependentData*>(this)->mnCalculatedCycles = nResult;
  83             }
  84         }
  85
  86         return mnCalculatedCycles;
  87     }
  88
  89     sal_Int64 SystemDependentData::estimateUsageInBytes() const
  90     {
  91         // default implementation has no idea
  92         return 0;
  93     }
  94 } // namespace basegfx
  95
  96 namespace basegfx
  97 {
  98     SystemDependentDataHolder::SystemDependentDataHolder()
  99     :   maSystemDependentReferences()
 100     {
 101     }
 102
 103     SystemDependentDataHolder::~SystemDependentDataHolder()
 104     {
 105         for(const auto& candidate : maSystemDependentReferences)
 106         {
 107             basegfx::SystemDependentData_SharedPtr aData(candidate.second.lock());
 108
 109             if(aData)
 110             {
 111                 aData->getSystemDependentDataManager().endUsage(aData);
 112             }
 113         }
 114     }
 115
 116     void SystemDependentDataHolder::addOrReplaceSystemDependentData(basegfx::SystemDependentData_SharedPtr& rData)
 117     {
 118         const size_t hash_code(typeid(*rData).hash_code());
 119         auto result(maSystemDependentReferences.find(hash_code));
 120
 121         if(result != maSystemDependentReferences.end())
 122         {
 123             basegfx::SystemDependentData_SharedPtr aData(result->second.lock());
 124
 125             if(aData)
 126             {
 127                 aData->getSystemDependentDataManager().endUsage(aData);
 128             }
 129
 130             maSystemDependentReferences.erase(result);
 131             result = maSystemDependentReferences.end();
 132         }
 133
 134         maSystemDependentReferences[hash_code] = rData;
 135         rData->getSystemDependentDataManager().startUsage(rData);
 136     }
 137
 138     SystemDependentData_SharedPtr SystemDependentDataHolder::getSystemDependentData(size_t hash_code) const
 139     {
 140         basegfx::SystemDependentData_SharedPtr aRetval;
 141         auto result(maSystemDependentReferences.find(hash_code));
 142
 143         if(result != maSystemDependentReferences.end())
 144         {
 145             aRetval = result->second.lock();
 146
 147             if(aRetval)
 148             {
 149                 aRetval->getSystemDependentDataManager().touchUsage(aRetval);
 150             }
 151             else
 152             {
 153                 const_cast< SystemDependentDataHolder* >(this)->maSystemDependentReferences.erase(result);
 154             }
 155         }
 156
 157         return aRetval;
 158     }
 159 } // namespace basegfx
 160
 161 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */