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