sc/source/core/tool/formularesult.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 "formularesult.hxx"
  11 #include "scmatrix.hxx"
  12
  13 namespace sc {
  14
  15 FormulaResultValue::FormulaResultValue() : meType(Invalid), mfValue(0.0), mnError(0) {}
  16 FormulaResultValue::FormulaResultValue( double fValue ) : meType(Value), mfValue(fValue), mnError(0) {}
  17 FormulaResultValue::FormulaResultValue( const svl::SharedString& rStr ) : meType(String), mfValue(0.0), maString(rStr), mnError(0) {}
  18 FormulaResultValue::FormulaResultValue( sal_uInt16 nErr ) : meType(Error), mfValue(0.0), mnError(nErr) {}
  19
  20 }
  21
  22 ScFormulaResult::ScFormulaResult() :
  23     mpToken(NULL), mnError(0), mbToken(true),
  24     mbEmpty(false), mbEmptyDisplayedAsString(false),
  25     meMultiline(MULTILINE_UNKNOWN) {}
  26
  27 ScFormulaResult::ScFormulaResult( const ScFormulaResult & r ) :
  28     mnError( r.mnError), mbToken( r.mbToken),
  29     mbEmpty( r.mbEmpty),
  30     mbEmptyDisplayedAsString( r.mbEmptyDisplayedAsString),
  31     meMultiline( r.meMultiline)
  32 {
  33     if (mbToken)
  34     {
  35         mpToken = r.mpToken;
  36         if (mpToken)
  37         {
  38             // Since matrix dimension and
  39             // results are assigned to a matrix
  40             // cell formula token we have to
  41             // clone that instead of sharing it.
  42             const ScMatrixFormulaCellToken* pMatFormula =
  43                 r.GetMatrixFormulaCellToken();
  44             if (pMatFormula)
  45             {
  46                 mpToken = new ScMatrixFormulaCellToken( *pMatFormula);
  47                 mpToken->IncRef();
  48             }
  49             else
  50                 IncrementTokenRef( mpToken);
  51         }
  52     }
  53     else
  54         mfValue = r.mfValue;
  55 }
  56
  57 ScFormulaResult::ScFormulaResult( const formula::FormulaToken* p ) :
  58     mnError(0), mbToken(false), mbEmpty(false), mbEmptyDisplayedAsString(false),
  59     meMultiline(MULTILINE_UNKNOWN)
  60 {
  61     SetToken( p);
  62 }
  63
  64 ScFormulaResult::~ScFormulaResult()
  65 {
  66     if (mbToken && mpToken)
  67         mpToken->DecRef();
  68 }
  69
  70 void ScFormulaResult::ResetToDefaults()
  71 {
  72     mnError = 0;
  73     mbEmpty = false;
  74     mbEmptyDisplayedAsString = false;
  75     meMultiline = MULTILINE_UNKNOWN;
  76 }
  77
  78 void ScFormulaResult::ResolveToken( const formula::FormulaToken * p )
  79 {
  80     ResetToDefaults();
  81     if (!p)
  82     {
  83         mpToken = p;
  84         mbToken = true;
  85     }
  86     else
  87     {
  88         switch (p->GetType())
  89         {
  90             case formula::svError:
  91                 mnError = p->GetError();
  92                 p->DecRef();
  93                 mbToken = false;
  94                 // set in case mnError is 0 now, which shouldn't happen but ...
  95                 mfValue = 0.0;
  96                 meMultiline = MULTILINE_FALSE;
  97                 break;
  98             case formula::svEmptyCell:
  99                 mbEmpty = true;
 100                 mbEmptyDisplayedAsString = static_cast<const ScEmptyCellToken*>(p)->IsDisplayedAsString();
 101                 p->DecRef();
 102                 mbToken = false;
 103                 meMultiline = MULTILINE_FALSE;
 104                 break;
 105             case formula::svDouble:
 106                 mfValue = p->GetDouble();
 107                 p->DecRef();
 108                 mbToken = false;
 109                 meMultiline = MULTILINE_FALSE;
 110                 break;
 111             default:
 112                 mpToken = p;
 113                 mbToken = true;
 114         }
 115     }
 116 }
 117
 118 ScFormulaResult & ScFormulaResult::operator=( const ScFormulaResult & r )
 119 {
 120     Assign( r);
 121     return *this;
 122 }
 123
 124 void ScFormulaResult::Assign( const ScFormulaResult & r )
 125 {
 126     if (this == &r)
 127         return;
 128     if (r.mbEmpty)
 129     {
 130         if (mbToken && mpToken)
 131             mpToken->DecRef();
 132         mbToken = false;
 133         mbEmpty = true;
 134         mbEmptyDisplayedAsString = r.mbEmptyDisplayedAsString;
 135         meMultiline = r.meMultiline;
 136     }
 137     else if (r.mbToken)
 138     {
 139         // Matrix formula cell token must be cloned, see copy-ctor.
 140         const ScMatrixFormulaCellToken* pMatFormula =
 141             r.GetMatrixFormulaCellToken();
 142         if (pMatFormula)
 143             SetToken( new ScMatrixFormulaCellToken( *pMatFormula));
 144         else
 145             SetToken( r.mpToken);
 146     }
 147     else
 148         SetDouble( r.mfValue);
 149     // If there was an error there will be an error, no matter what Set...()
 150     // methods did.
 151     mnError = r.mnError;
 152 }
 153
 154 void ScFormulaResult::SetToken( const formula::FormulaToken* p )
 155 {
 156     ResetToDefaults();
 157     IncrementTokenRef( p);
 158     // Handle a result obtained from the interpreter to be assigned to a matrix
 159     // formula cell's ScMatrixFormulaCellToken.
 160     ScMatrixFormulaCellToken* pMatFormula = GetMatrixFormulaCellTokenNonConst();
 161     if (pMatFormula)
 162     {
 163         const ScMatrixCellResultToken* pMatResult =
 164             (p && p->GetType() == formula::svMatrixCell ?
 165              dynamic_cast<const ScMatrixCellResultToken*>(p) : NULL);
 166         if (pMatResult)
 167         {
 168             const ScMatrixFormulaCellToken* pNewMatFormula =
 169                 dynamic_cast<const ScMatrixFormulaCellToken*>(pMatResult);
 170             if (pNewMatFormula && (pMatFormula->GetMatCols() <= 0 || pMatFormula->GetMatRows() <= 0))
 171             {
 172                 SAL_WARN( "sc", "ScFormulaResult::SetToken: pNewMatFormula and pMatFormula, overriding matrix formula dimension; intended?");
 173                 pMatFormula->SetMatColsRows( pNewMatFormula->GetMatCols(),
 174                         pNewMatFormula->GetMatRows());
 175             }
 176             pMatFormula->Assign( *pMatResult);
 177             p->DecRef();
 178         }
 179         else if (p)
 180         {
 181             // This may be the result of some constant expression like
 182             // {="string"} that doesn't result in a matrix but still would
 183             // display the result in all cells of this matrix formula.
 184             pMatFormula->Assign( *p);
 185             p->DecRef();
 186         }
 187         else
 188         {
 189             // NULL result? Well, if you say so ...
 190             pMatFormula->ResetResult();
 191         }
 192     }
 193     else
 194     {
 195         if (mbToken && mpToken)
 196             mpToken->DecRef();
 197         ResolveToken( p);
 198     }
 199 }
 200
 201 void ScFormulaResult::SetDouble( double f )
 202 {
 203     ResetToDefaults();
 204     // Handle a result obtained from the interpreter to be assigned to a matrix
 205     // formula cell's ScMatrixFormulaCellToken.
 206     ScMatrixFormulaCellToken* pMatFormula = GetMatrixFormulaCellTokenNonConst();
 207     if (pMatFormula)
 208         pMatFormula->SetUpperLeftDouble( f);
 209     else
 210     {
 211         if (mbToken && mpToken)
 212             mpToken->DecRef();
 213         mfValue = f;
 214         mbToken = false;
 215         meMultiline = MULTILINE_FALSE;
 216     }
 217 }
 218
 219 formula::StackVar ScFormulaResult::GetType() const
 220 {
 221     // Order is significant.
 222     if (mnError)
 223         return formula::svError;
 224     if (mbEmpty)
 225         return formula::svEmptyCell;
 226     if (!mbToken)
 227         return formula::svDouble;
 228     if (mpToken)
 229         return mpToken->GetType();
 230     return formula::svUnknown;
 231 }
 232
 233 formula::StackVar ScFormulaResult::GetCellResultType() const
 234 {
 235     formula::StackVar sv = GetType();
 236     if (sv == formula::svMatrixCell)
 237         // don't need to test for mpToken here, GetType() already did it
 238         sv = static_cast<const ScMatrixCellResultToken*>(mpToken)->GetUpperLeftType();
 239     return sv;
 240 }
 241
 242 bool ScFormulaResult::IsEmptyDisplayedAsString() const
 243 {
 244     if (mbEmpty)
 245         return mbEmptyDisplayedAsString;
 246     if (GetType() == formula::svMatrixCell)
 247     {
 248         // don't need to test for mpToken here, GetType() already did it
 249         const ScEmptyCellToken* p = dynamic_cast<const ScEmptyCellToken*>(
 250                 static_cast<const ScMatrixCellResultToken*>(
 251                     mpToken)->GetUpperLeftToken().get());
 252         if (p)
 253             return p->IsDisplayedAsString();
 254     }
 255     return false;
 256 }
 257
 258 namespace {
 259
 260 inline bool isValue( formula::StackVar sv )
 261 {
 262     return sv == formula::svDouble || sv == formula::svError
 263         || sv == formula::svEmptyCell || sv == formula::svHybridValueCell;
 264 }
 265
 266 inline bool isString( formula::StackVar sv )
 267 {
 268     switch (sv)
 269     {
 270         case formula::svString:
 271         case formula::svHybridCell:
 272         case formula::svHybridValueCell:
 273             return true;
 274         default:
 275             break;
 276     }
 277
 278     return false;
 279 }
 280
 281 }
 282
 283 bool ScFormulaResult::IsValue() const
 284 {
 285     return isValue(GetCellResultType());
 286 }
 287
 288 bool ScFormulaResult::IsValueNoError() const
 289 {
 290     switch (GetCellResultType())
 291     {
 292         case formula::svDouble:
 293         case formula::svEmptyCell:
 294         case formula::svHybridValueCell:
 295             return true;
 296         default:
 297             return false;
 298     }
 299 }
 300
 301 bool ScFormulaResult::IsMultiline() const
 302 {
 303     if (meMultiline == MULTILINE_UNKNOWN)
 304     {
 305         svl::SharedString aStr = GetString();
 306         if (!aStr.isEmpty() && aStr.getString().indexOf('\n') != -1)
 307             const_cast<ScFormulaResult*>(this)->meMultiline = MULTILINE_TRUE;
 308         else
 309             const_cast<ScFormulaResult*>(this)->meMultiline = MULTILINE_FALSE;
 310     }
 311     return meMultiline == MULTILINE_TRUE;
 312 }
 313
 314 bool ScFormulaResult::GetErrorOrDouble( sal_uInt16& rErr, double& rVal ) const
 315 {
 316     if (mnError)
 317     {
 318         rErr = mnError;
 319         return true;
 320     }
 321
 322     formula::StackVar sv = GetCellResultType();
 323     if (sv == formula::svError)
 324     {
 325         if (GetType() == formula::svMatrixCell)
 326         {
 327             // don't need to test for mpToken here, GetType() already did it
 328             rErr = static_cast<const ScMatrixCellResultToken*>(mpToken)->
 329                 GetUpperLeftToken()->GetError();
 330         }
 331         else if (mpToken)
 332         {
 333             rErr = mpToken->GetError();
 334         }
 335     }
 336
 337     if (rErr)
 338         return true;
 339
 340     if (!isValue(sv))
 341         return false;
 342
 343     rVal = GetDouble();
 344     return true;
 345 }
 346
 347 sc::FormulaResultValue ScFormulaResult::GetResult() const
 348 {
 349     if (mnError)
 350         return sc::FormulaResultValue(mnError);
 351
 352     formula::StackVar sv = GetCellResultType();
 353     sal_uInt16 nErr = 0;
 354     if (sv == formula::svError)
 355     {
 356         if (GetType() == formula::svMatrixCell)
 357         {
 358             // don't need to test for mpToken here, GetType() already did it
 359             nErr = static_cast<const ScMatrixCellResultToken*>(mpToken)->
 360                 GetUpperLeftToken()->GetError();
 361         }
 362         else if (mpToken)
 363         {
 364             nErr = mpToken->GetError();
 365         }
 366     }
 367
 368     if (nErr)
 369         return sc::FormulaResultValue(nErr);
 370
 371     if (isValue(sv))
 372         return sc::FormulaResultValue(GetDouble());
 373
 374     if (!mbToken)
 375         // String result type needs token.
 376         return sc::FormulaResultValue();
 377
 378     if (isString(sv))
 379         return sc::FormulaResultValue(GetString());
 380
 381     // Invalid
 382     return sc::FormulaResultValue();
 383 }
 384
 385 sal_uInt16 ScFormulaResult::GetResultError() const
 386 {
 387     if (mnError)
 388         return mnError;
 389     formula::StackVar sv = GetCellResultType();
 390     if (sv == formula::svError)
 391     {
 392         if (GetType() == formula::svMatrixCell)
 393             // don't need to test for mpToken here, GetType() already did it
 394             return static_cast<const ScMatrixCellResultToken*>(mpToken)->
 395                 GetUpperLeftToken()->GetError();
 396         if (mpToken)
 397             return mpToken->GetError();
 398     }
 399     return 0;
 400 }
 401
 402 void ScFormulaResult::SetResultError( sal_uInt16 nErr )
 403 {
 404     mnError = nErr;
 405 }
 406
 407 formula::FormulaConstTokenRef ScFormulaResult::GetToken() const
 408 {
 409     if (mbToken)
 410         return mpToken;
 411     return NULL;
 412 }
 413
 414 formula::FormulaConstTokenRef ScFormulaResult::GetCellResultToken() const
 415 {
 416     if (GetType() == formula::svMatrixCell)
 417         // don't need to test for mpToken here, GetType() already did it
 418         return static_cast<const ScMatrixCellResultToken*>(mpToken)->GetUpperLeftToken();
 419     return GetToken();
 420 }
 421
 422 double ScFormulaResult::GetDouble() const
 423 {
 424     if (mbToken)
 425     {
 426         // Should really not be of type formula::svDouble here.
 427         if (mpToken)
 428         {
 429             switch (mpToken->GetType())
 430             {
 431                 case formula::svHybridCell:
 432                 case formula::svHybridValueCell:
 433                     return mpToken->GetDouble();
 434                 case formula::svMatrixCell:
 435                     {
 436                         const ScMatrixCellResultToken* p =
 437                             static_cast<const ScMatrixCellResultToken*>(mpToken);
 438                         if (p->GetUpperLeftType() == formula::svDouble)
 439                             return p->GetUpperLeftToken()->GetDouble();
 440                     }
 441                     break;
 442                 default:
 443                     ;   // nothing
 444             }
 445         }
 446         return 0.0;
 447     }
 448     if (mbEmpty)
 449         return 0.0;
 450     return mfValue;
 451 }
 452
 453 svl::SharedString ScFormulaResult::GetString() const
 454 {
 455     if (mbToken && mpToken)
 456     {
 457         switch (mpToken->GetType())
 458         {
 459             case formula::svString:
 460             case formula::svHybridCell:
 461             case formula::svHybridValueCell:
 462                 return mpToken->GetString();
 463             case formula::svMatrixCell:
 464                 {
 465                     const ScMatrixCellResultToken* p =
 466                         static_cast<const ScMatrixCellResultToken*>(mpToken);
 467                     if (p->GetUpperLeftType() == formula::svString)
 468                         return p->GetUpperLeftToken()->GetString();
 469                 }
 470                 break;
 471             default:
 472                 ;   // nothing
 473         }
 474     }
 475     return svl::SharedString::getEmptyString();
 476 }
 477
 478 ScConstMatrixRef ScFormulaResult::GetMatrix() const
 479 {
 480     if (GetType() == formula::svMatrixCell)
 481         return mpToken->GetMatrix();
 482     return NULL;
 483 }
 484
 485 const OUString& ScFormulaResult::GetHybridFormula() const
 486 {
 487     if (GetType() == formula::svHybridCell)
 488     {
 489         const ScHybridCellToken* p = dynamic_cast<const ScHybridCellToken*>(mpToken);
 490         if (p)
 491             return p->GetFormula();
 492     }
 493     return EMPTY_OUSTRING;
 494 }
 495
 496 void ScFormulaResult::SetHybridDouble( double f )
 497 {
 498     ResetToDefaults();
 499     if (mbToken && mpToken)
 500     {
 501         if(GetType() == formula::svMatrixCell)
 502             SetDouble(f);
 503         else
 504         {
 505             svl::SharedString aString = GetString();
 506             OUString aFormula( GetHybridFormula());
 507             mpToken->DecRef();
 508             mpToken = new ScHybridCellToken( f, aString, aFormula);
 509             mpToken->IncRef();
 510         }
 511     }
 512     else
 513     {
 514         mfValue = f;
 515         mbToken = false;
 516         meMultiline = MULTILINE_FALSE;
 517     }
 518 }
 519
 520 void ScFormulaResult::SetHybridString( const svl::SharedString& rStr )
 521 {
 522     // Obtain values before changing anything.
 523     double f = GetDouble();
 524     OUString aFormula( GetHybridFormula());
 525     ResetToDefaults();
 526     if (mbToken && mpToken)
 527         mpToken->DecRef();
 528     mpToken = new ScHybridCellToken( f, rStr, aFormula);
 529     mpToken->IncRef();
 530     mbToken = true;
 531 }
 532
 533 void ScFormulaResult::SetHybridFormula( const OUString & rFormula )
 534 {
 535     // Obtain values before changing anything.
 536     double f = GetDouble();
 537     svl::SharedString aStr = GetString();
 538     ResetToDefaults();
 539     if (mbToken && mpToken)
 540         mpToken->DecRef();
 541     mpToken = new ScHybridCellToken( f, aStr, rFormula);
 542     mpToken->IncRef();
 543     mbToken = true;
 544 }
 545
 546 void ScFormulaResult::SetMatrix( SCCOL nCols, SCROW nRows, const ScConstMatrixRef& pMat, formula::FormulaToken* pUL )
 547 {
 548     ResetToDefaults();
 549     if (mbToken && mpToken)
 550         mpToken->DecRef();
 551     mpToken = new ScMatrixFormulaCellToken(nCols, nRows, pMat, pUL);
 552     mpToken->IncRef();
 553     mbToken = true;
 554 }
 555
 556 const ScMatrixFormulaCellToken* ScFormulaResult::GetMatrixFormulaCellToken() const
 557 {
 558     return (GetType() == formula::svMatrixCell ?
 559             dynamic_cast<const ScMatrixFormulaCellToken*>(mpToken) : NULL);
 560 }
 561
 562 ScMatrixFormulaCellToken* ScFormulaResult::GetMatrixFormulaCellTokenNonConst()
 563 {
 564     return const_cast<ScMatrixFormulaCellToken*>( GetMatrixFormulaCellToken());
 565 }
 566
 567 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */