sc/source/core/tool/recursionhelper.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 <recursionhelper.hxx>
  11 #include <formulacell.hxx>
  12
  13 void ScRecursionHelper::Init()
  14 {
  15     nRecursionCount    = 0;
  16     nDependencyComputationLevel = 0;
  17     bInRecursionReturn = bDoingRecursion = bInIterationReturn = false;
  18     bAbortingDependencyComputation = false;
  19     aInsertPos = GetIterationEnd();
  20     ResetIteration();
  21     // Must not force clear aFGList ever.
  22 }
  23
  24 void ScRecursionHelper::ResetIteration()
  25 {
  26     aLastIterationStart = GetIterationEnd();
  27     nIteration = 0;
  28     bConverging = false;
  29 }
  30
  31 ScRecursionHelper::ScRecursionHelper()
  32 {
  33     pFGSet = nullptr;
  34     bGroupsIndependent = true;
  35     Init();
  36 }
  37
  38 void ScRecursionHelper::SetInRecursionReturn( bool b )
  39 {
  40     // Do not use IsInRecursionReturn() here, it decouples iteration.
  41     if (b && !bInRecursionReturn)
  42         aInsertPos = aRecursionFormulas.begin();
  43     bInRecursionReturn = b;
  44 }
  45
  46 void ScRecursionHelper::Insert(
  47     ScFormulaCell* p, bool bOldRunning, const ScFormulaResult & rRes )
  48 {
  49     aRecursionFormulas.insert( aInsertPos, ScFormulaRecursionEntry( p,
  50                 bOldRunning, rRes));
  51 }
  52
  53 void ScRecursionHelper::SetInIterationReturn( bool b )
  54 {
  55     // An iteration return is always coupled to a recursion return.
  56     SetInRecursionReturn( b);
  57     bInIterationReturn = b;
  58 }
  59
  60 void ScRecursionHelper::StartIteration()
  61 {
  62     SetInIterationReturn( false);
  63     nIteration = 1;
  64     bConverging = false;
  65     aLastIterationStart = GetIterationStart();
  66 }
  67
  68 void ScRecursionHelper::ResumeIteration()
  69 {
  70     SetInIterationReturn( false);
  71     aLastIterationStart = GetIterationStart();
  72 }
  73
  74 void ScRecursionHelper::IncIteration()
  75 {
  76     ++nIteration;
  77 }
  78
  79 void ScRecursionHelper::EndIteration()
  80 {
  81     aRecursionFormulas.erase( GetIterationStart(), GetIterationEnd());
  82     ResetIteration();
  83 }
  84
  85 ScFormulaRecursionList::iterator ScRecursionHelper::GetIterationStart()
  86 {
  87     return aRecursionFormulas.begin();
  88 }
  89
  90 ScFormulaRecursionList::iterator ScRecursionHelper::GetIterationEnd()
  91 {
  92     return aRecursionFormulas.end();
  93 }
  94
  95 void ScRecursionHelper::Clear()
  96 {
  97     aRecursionFormulas.clear();
  98     while (!aRecursionInIterationStack.empty())
  99         aRecursionInIterationStack.pop();
 100     Init();
 101 }
 102
 103 static ScFormulaCell* lcl_GetTopCell(ScFormulaCell* pCell)
 104 {
 105     if (!pCell)
 106         return nullptr;
 107
 108     const ScFormulaCellGroupRef& mxGroup = pCell->GetCellGroup();
 109     if (!mxGroup)
 110         return pCell;
 111     return mxGroup->mpTopCell;
 112 }
 113
 114 bool ScRecursionHelper::PushFormulaGroup(ScFormulaCell* pCell)
 115 {
 116     assert(pCell);
 117
 118     if (pCell->GetSeenInPath())
 119     {
 120         // Found a simple cycle of formula-groups.
 121         // Disable group calc for all elements of this cycle.
 122         sal_Int32 nIdx = aFGList.size();
 123         assert(nIdx > 0);
 124         do
 125         {
 126             --nIdx;
 127             assert(nIdx >= 0);
 128             const ScFormulaCellGroupRef& mxGroup = aFGList[nIdx]->GetCellGroup();
 129             if (mxGroup)
 130                 mxGroup->mbPartOfCycle = true;
 131         } while (aFGList[nIdx] != pCell);
 132
 133         return false;
 134     }
 135
 136     pCell->SetSeenInPath(true);
 137     aFGList.push_back(pCell);
 138     aInDependencyEvalMode.push_back(false);
 139     return true;
 140 }
 141
 142 void ScRecursionHelper::PopFormulaGroup()
 143 {
 144     assert(aFGList.size() == aInDependencyEvalMode.size());
 145     if (aFGList.empty())
 146         return;
 147     ScFormulaCell* pCell = aFGList.back();
 148     pCell->SetSeenInPath(false);
 149     aFGList.pop_back();
 150     aInDependencyEvalMode.pop_back();
 151 }
 152
 153 bool ScRecursionHelper::AnyCycleMemberInDependencyEvalMode(const ScFormulaCell* pCell)
 154 {
 155     assert(pCell);
 156
 157     if (pCell->GetSeenInPath())
 158     {
 159         // Found a simple cycle of formula-groups.
 160         sal_Int32 nIdx = aFGList.size();
 161         assert(nIdx > 0);
 162         do
 163         {
 164             --nIdx;
 165             assert(nIdx >= 0);
 166             const ScFormulaCellGroupRef& mxGroup = aFGList[nIdx]->GetCellGroup();
 167             // Found a cycle member FG that is in dependency evaluation mode.
 168             if (mxGroup && aInDependencyEvalMode[nIdx])
 169                 return true;
 170         } while (aFGList[nIdx] != pCell);
 171
 172         return false;
 173     }
 174
 175     return false;
 176 }
 177
 178 bool ScRecursionHelper::AnyParentFGInCycle()
 179 {
 180     sal_Int32 nIdx = aFGList.size() - 1;
 181     while (nIdx >= 0)
 182     {
 183         const ScFormulaCellGroupRef& mxGroup = aFGList[nIdx]->GetCellGroup();
 184         if (mxGroup)
 185             return mxGroup->mbPartOfCycle;
 186         --nIdx;
 187     };
 188     return false;
 189 }
 190
 191 void ScRecursionHelper::SetFormulaGroupDepEvalMode(bool bSet)
 192 {
 193     assert(aFGList.size());
 194     assert(aFGList.size() == aInDependencyEvalMode.size());
 195     assert(aFGList.back()->GetCellGroup());
 196     aInDependencyEvalMode.back() = bSet;
 197 }
 198
 199 void ScRecursionHelper::AbortDependencyComputation()
 200 {
 201     assert( nDependencyComputationLevel > 0 );
 202     bAbortingDependencyComputation = true;
 203 }
 204
 205 void ScRecursionHelper::IncDepComputeLevel()
 206 {
 207     ++nDependencyComputationLevel;
 208 }
 209
 210 void ScRecursionHelper::DecDepComputeLevel()
 211 {
 212     --nDependencyComputationLevel;
 213     bAbortingDependencyComputation = false;
 214 }
 215
 216 void ScRecursionHelper::AddTemporaryGroupCell(ScFormulaCell* cell)
 217 {
 218     aTemporaryGroupCells.push_back( cell );
 219 }
 220
 221 void ScRecursionHelper::CleanTemporaryGroupCells()
 222 {
 223     if( GetRecursionCount() == 0 )
 224     {
 225         for( ScFormulaCell* cell : aTemporaryGroupCells )
 226             cell->SetCellGroup( nullptr );
 227         aTemporaryGroupCells.clear();
 228     }
 229 }
 230
 231 bool ScRecursionHelper::CheckFGIndependence(ScFormulaCellGroup* pFG)
 232 {
 233     if (pFGSet && pFGSet->count(pFG))
 234     {
 235         bGroupsIndependent = false;
 236         return false;
 237     }
 238
 239     return true;
 240 }
 241
 242 ScFormulaGroupCycleCheckGuard::ScFormulaGroupCycleCheckGuard(ScRecursionHelper& rRecursionHelper, ScFormulaCell* pCell) :
 243     mrRecHelper(rRecursionHelper)
 244 {
 245     if (pCell)
 246     {
 247         pCell = lcl_GetTopCell(pCell);
 248         mbShouldPop = mrRecHelper.PushFormulaGroup(pCell);
 249     }
 250     else
 251         mbShouldPop = false;
 252 }
 253
 254 ScFormulaGroupCycleCheckGuard::~ScFormulaGroupCycleCheckGuard()
 255 {
 256     if (mbShouldPop)
 257         mrRecHelper.PopFormulaGroup();
 258 }
 259
 260 ScFormulaGroupDependencyComputeGuard::ScFormulaGroupDependencyComputeGuard(ScRecursionHelper& rRecursionHelper) :
 261     mrRecHelper(rRecursionHelper)
 262 {
 263     mrRecHelper.IncDepComputeLevel();
 264     mrRecHelper.SetFormulaGroupDepEvalMode(true);
 265 }
 266
 267 ScFormulaGroupDependencyComputeGuard::~ScFormulaGroupDependencyComputeGuard()
 268 {
 269     mrRecHelper.SetFormulaGroupDepEvalMode(false);
 270     mrRecHelper.DecDepComputeLevel();
 271 }
 272
 273 ScCheckIndependentFGGuard::ScCheckIndependentFGGuard(ScRecursionHelper& rRecursionHelper,
 274                                                      o3tl::sorted_vector<ScFormulaCellGroup*>* pSet) :
 275     mrRecHelper(rRecursionHelper),
 276     mbUsedFGSet(false)
 277 {
 278     if (!mrRecHelper.HasFormulaGroupSet())
 279     {
 280         mrRecHelper.SetFormulaGroupSet(pSet);
 281         mrRecHelper.SetGroupsIndependent(true);
 282         mbUsedFGSet = true;
 283     }
 284 }
 285
 286 ScCheckIndependentFGGuard::~ScCheckIndependentFGGuard()
 287 {
 288     if (mbUsedFGSet)
 289     {
 290         // Reset to defaults.
 291         mrRecHelper.SetFormulaGroupSet(nullptr);
 292         mrRecHelper.SetGroupsIndependent(true);
 293     }
 294 }
 295
 296 bool ScCheckIndependentFGGuard::AreGroupsIndependent()
 297 {
 298     if (!mbUsedFGSet)
 299         return false;
 300
 301     return mrRecHelper.AreGroupsIndependent();
 302 }
 303
 304 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */