sc/inc/formularesult.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: formularesult.hxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef SC_FORMULARESULT_HXX
  32 #define SC_FORMULARESULT_HXX
  33
  34 #include "token.hxx"
  35
  36
  37 /** Store a variable formula cell result, balancing between runtime performance
  38     and memory consumption. */
  39 class ScFormulaResult
  40 {
  41     typedef unsigned char Multiline;
  42     static const Multiline MULTILINE_UNKNOWN = 0;
  43     static const Multiline MULTILINE_FALSE   = 1;
  44     static const Multiline MULTILINE_TRUE    = 2;
  45
  46     union
  47     {
  48         double          mfValue;    // double result direct for performance and memory consumption
  49         const formula::FormulaToken*  mpToken;    // if not, result token obtained from interpreter
  50     };
  51     USHORT              mnError;    // error code
  52     bool                mbToken :1; // whether content of union is a token
  53     bool                mbEmpty :1; // empty cell result
  54     bool                mbEmptyDisplayedAsString :1;    // only if mbEmpty
  55     Multiline           meMultiline :2; // result is multiline
  56
  57     /** Reset mnError, mbEmpty and mbEmptyDisplayedAsString to their defaults
  58         prior to assigning other types */
  59     inline  void                ResetToDefaults();
  60
  61     /** If token is of formula::svError set error code and decrement RefCount.
  62         If token is of formula::svEmptyCell set mbEmpty and mbEmptyAsString and
  63         decrement RefCount.
  64         If token is of formula::svDouble set mfValue and decrement RefCount.
  65         Else assign token to mpToken. NULL is valid => svUnknown.
  66         Other member variables are set accordingly.
  67         @precondition: Token MUST had been IncRef'ed prior to this call!
  68         @precondition: An already existing different mpToken MUST had been
  69         DecRef'ed prior to this call, p will be assigned to mpToken if not
  70         resolved.
  71         ATTENTION! Token may get deleted in this call! */
  72     inline  void                ResolveToken( const formula::FormulaToken * p );
  73
  74 public:
  75                                 /** Effectively type svUnknown. */
  76                                 ScFormulaResult()
  77                                     : mpToken(NULL), mnError(0), mbToken(true),
  78                                     mbEmpty(false), mbEmptyDisplayedAsString(false),
  79                                     meMultiline(MULTILINE_UNKNOWN) {}
  80
  81                                 ScFormulaResult( const ScFormulaResult & r )
  82                                     : mnError( r.mnError), mbToken( r.mbToken),
  83                                     mbEmpty( r.mbEmpty),
  84                                     mbEmptyDisplayedAsString( r.mbEmptyDisplayedAsString),
  85                                     meMultiline( r.meMultiline)
  86                                 {
  87                                     if (mbToken)
  88                                     {
  89                                         mpToken = r.mpToken;
  90                                         if (mpToken)
  91                                         {
  92                                             // Since matrix dimension and
  93                                             // results are assigned to a matrix
  94                                             // cell formula token we have to
  95                                             // clone that instead of sharing it.
  96                                             const ScMatrixFormulaCellToken* pMatFormula =
  97                                                 r.GetMatrixFormulaCellToken();
  98                                             if (pMatFormula)
  99                                                 mpToken = new ScMatrixFormulaCellToken( *pMatFormula);
 100                                             mpToken->IncRef();
 101                                         }
 102                                     }
 103                                     else
 104                                         mfValue = r.mfValue;
 105                                 }
 106
 107     /** Same comments as for SetToken() apply! */
 108     explicit                    ScFormulaResult( const formula::FormulaToken* p )
 109                                     : mnError(0), mbToken(false),
 110                                     mbEmpty(false), mbEmptyDisplayedAsString(false),
 111                                     meMultiline(MULTILINE_UNKNOWN)
 112                                 {
 113                                     SetToken( p);
 114                                 }
 115
 116                                 ~ScFormulaResult()
 117                                 {
 118                                     if (mbToken && mpToken)
 119                                         mpToken->DecRef();
 120                                 }
 121
 122     /** Well, guess what ... */
 123     inline  ScFormulaResult &   operator=( const ScFormulaResult & r );
 124
 125     /** Assignment as in operator=() but without return */
 126     inline  void                Assign( const ScFormulaResult & r );
 127
 128     /** Sets a direct double if token type is formula::svDouble, or mbEmpty if
 129         formula::svEmptyCell, else token. If p is NULL, that is set as well, effectively
 130         resulting in GetType()==svUnknown. If the already existing result is
 131         ScMatrixFormulaCellToken, the upper left ist set to token.
 132
 133         ATTENTION! formula::FormulaToken had to be allocated using 'new' and if of type
 134         formula::svDouble and no RefCount was set may not be used after this call
 135         because it was deleted after decrement! */
 136     inline  void                SetToken( const formula::FormulaToken* p );
 137
 138     /** May be NULL if SetToken() did so, also if type formula::svDouble or formula::svError! */
 139     inline  formula::FormulaConstTokenRef     GetToken() const;
 140
 141     /** Return upper left token if formula::svMatrixCell, else return GetToken().
 142         May be NULL if SetToken() did so, also if type formula::svDouble or formula::svError! */
 143     inline  formula::FormulaConstTokenRef     GetCellResultToken() const;
 144
 145     /** Return type of result, including formula::svError, formula::svEmptyCell, formula::svDouble and
 146         formula::svMatrixCell. */
 147     inline  formula::StackVar            GetType() const;
 148
 149     /** If type is formula::svMatrixCell return the type of upper left element, else
 150         GetType() */
 151     inline  formula::StackVar            GetCellResultType() const;
 152
 153     /** If type is formula::svEmptyCell (including matrix upper left) and should be
 154         displayed as empty string */
 155     inline  bool                IsEmptyDisplayedAsString() const;
 156
 157     /** Test for cell result type formula::svDouble, including upper left if
 158         formula::svMatrixCell. Also included is formula::svError for legacy, because previously
 159         an error result was treated like a numeric value at some places in
 160         ScFormulaCell. Also included is formula::svEmptyCell as a reference to an empty
 161         cell usually is treated as numeric 0. Use GetCellResultType() for
 162         details instead. */
 163     inline  bool                IsValue() const;
 164
 165     /** Determines whether or not the result is a string containing more than
 166         one paragraph */
 167     inline  bool                IsMultiline() const;
 168
 169     /** Get error code if set or GetCellResultType() is formula::svError or svUnknown,
 170         else 0. */
 171     inline  USHORT              GetResultError() const;
 172
 173     /** Set error code, don't touch token or double. */
 174     inline  void                SetResultError( USHORT nErr );
 175
 176     /** Set direct double. Shouldn't be used externally except in
 177         ScFormulaCell for rounded CalcAsShown or SetErrCode(). If
 178         ScMatrixFormulaCellToken the token isn't replaced but upper left result
 179         is modified instead, but only if it was of type formula::svDouble before or not
 180         set at all. */
 181     inline  void                SetDouble( double f );
 182
 183     /** Return value if type formula::svDouble or formula::svHybridCell or formula::svMatrixCell and upper
 184         left formula::svDouble, else 0.0 */
 185     inline  double              GetDouble() const;
 186
 187     /** Return string if type formula::svString or formula::svHybridCell or formula::svMatrixCell and
 188         upper left formula::svString, else empty string. */
 189     inline  const String &      GetString() const;
 190
 191     /** Return matrix if type formula::svMatrixCell and ScMatrix present, else NULL. */
 192     inline  ScConstMatrixRef    GetMatrix() const;
 193
 194     /** Return formula string if type formula::svHybridCell, else empty string. */
 195     inline  const String &      GetHybridFormula() const;
 196
 197     /** Should only be used by import filters, best in the order
 198         SetHybridDouble(), SetHybridString(), or only SetHybridString() for
 199         formula string to be compiled later. */
 200     inline  void                SetHybridDouble( double f );
 201
 202     /** Should only be used by import filters, best in the order
 203         SetHybridDouble(), SetHybridString()/SetHybridFormula(), or only
 204         SetHybridFormula() for formula string to be compiled later. */
 205     inline  void                SetHybridString( const String & rStr );
 206
 207     /** Should only be used by import filters, best in the order
 208         SetHybridDouble(), SetHybridString()/SetHybridFormula(), or only
 209         SetHybridFormula() for formula string to be compiled later. */
 210     inline  void                SetHybridFormula( const String & rFormula );
 211
 212     /** Get the const ScMatrixFormulaCellToken* if token is of that type, else
 213         NULL. */
 214     inline const ScMatrixFormulaCellToken* GetMatrixFormulaCellToken() const;
 215
 216     /** Get the ScMatrixFormulaCellToken* if token is of that type, else NULL.
 217         Shouldn't be used externally except by ScFormulaCell::SetMatColsRows(). */
 218     inline ScMatrixFormulaCellToken* GetMatrixFormulaCellTokenNonConst();
 219 };
 220
 221
 222 inline void ScFormulaResult::ResetToDefaults()
 223 {
 224     mnError = 0;
 225     mbEmpty = false;
 226     mbEmptyDisplayedAsString = false;
 227     meMultiline = MULTILINE_UNKNOWN;
 228 }
 229
 230
 231 inline void ScFormulaResult::ResolveToken( const formula::FormulaToken * p )
 232 {
 233     ResetToDefaults();
 234     if (!p)
 235     {
 236         mpToken = p;
 237         mbToken = true;
 238     }
 239     else
 240     {
 241         switch (p->GetType())
 242         {
 243             case formula::svError:
 244                 mnError = p->GetError();
 245                 p->DecRef();
 246                 mbToken = false;
 247                 // set in case mnError is 0 now, which shouldn't happen but ...
 248                 mfValue = 0.0;
 249                 meMultiline = MULTILINE_FALSE;
 250                 break;
 251             case formula::svEmptyCell:
 252                 mbEmpty = true;
 253                 mbEmptyDisplayedAsString = static_cast<const ScEmptyCellToken*>(p)->IsDisplayedAsString();
 254                 p->DecRef();
 255                 mbToken = false;
 256                 meMultiline = MULTILINE_FALSE;
 257                 break;
 258             case formula::svDouble:
 259                 mfValue = p->GetDouble();
 260                 p->DecRef();
 261                 mbToken = false;
 262                 meMultiline = MULTILINE_FALSE;
 263                 break;
 264             default:
 265                 mpToken = p;
 266                 mbToken = true;
 267         }
 268     }
 269 }
 270
 271
 272 inline ScFormulaResult & ScFormulaResult::operator=( const ScFormulaResult & r )
 273 {
 274     Assign( r);
 275     return *this;
 276 }
 277
 278
 279 inline void ScFormulaResult::Assign( const ScFormulaResult & r )
 280 {
 281     if (this == &r)
 282         return;
 283     if (r.mbEmpty)
 284     {
 285         if (mbToken && mpToken)
 286             mpToken->DecRef();
 287         mbToken = false;
 288         mbEmpty = true;
 289         mbEmptyDisplayedAsString = r.mbEmptyDisplayedAsString;
 290         meMultiline = r.meMultiline;
 291     }
 292     else if (r.mbToken)
 293     {
 294         // Matrix formula cell token must be cloned, see copy-ctor.
 295         const ScMatrixFormulaCellToken* pMatFormula =
 296             r.GetMatrixFormulaCellToken();
 297         if (pMatFormula)
 298             SetToken( new ScMatrixFormulaCellToken( *pMatFormula));
 299         else
 300             SetToken( r.mpToken);
 301     }
 302     else
 303         SetDouble( r.mfValue);
 304     // If there was an error there will be an error, no matter what Set...()
 305     // methods did.
 306     mnError = r.mnError;
 307 }
 308
 309
 310 inline void ScFormulaResult::SetToken( const formula::FormulaToken* p )
 311 {
 312     ResetToDefaults();
 313     if (p)
 314         p->IncRef();
 315     // Handle a result obtained from the interpreter to be assigned to a matrix
 316     // formula cell's ScMatrixFormulaCellToken.
 317     ScMatrixFormulaCellToken* pMatFormula = GetMatrixFormulaCellTokenNonConst();
 318     if (pMatFormula)
 319     {
 320         const ScMatrixCellResultToken* pMatResult =
 321             (p && p->GetType() == formula::svMatrixCell ?
 322              dynamic_cast<const ScMatrixCellResultToken*>(p) : NULL);
 323         if (pMatResult)
 324         {
 325             const ScMatrixFormulaCellToken* pNewMatFormula =
 326                 dynamic_cast<const ScMatrixFormulaCellToken*>(pMatResult);
 327             if (pNewMatFormula)
 328             {
 329                 DBG_ERRORFILE( "ScFormulaResult::SetToken: pNewMatFormula and pMatFormula, overriding matrix formula dimension; intended?");
 330                 pMatFormula->SetMatColsRows( pNewMatFormula->GetMatCols(),
 331                         pNewMatFormula->GetMatRows());
 332             }
 333             pMatFormula->Assign( *pMatResult);
 334             p->DecRef();
 335         }
 336         else if (p)
 337         {
 338             // This may be the result of some constant expression like
 339             // {="string"} that doesn't result in a matrix but still would
 340             // display the result in all cells of this matrix formula.
 341             pMatFormula->Assign( *p);
 342             p->DecRef();
 343         }
 344         else
 345         {
 346             // NULL result? Well, if you say so ...
 347             pMatFormula->ResetResult();
 348         }
 349     }
 350     else
 351     {
 352         if (mbToken && mpToken)
 353             mpToken->DecRef();
 354         ResolveToken( p);
 355     }
 356 }
 357
 358
 359 inline void ScFormulaResult::SetDouble( double f )
 360 {
 361     ResetToDefaults();
 362     // Handle a result obtained from the interpreter to be assigned to a matrix
 363     // formula cell's ScMatrixFormulaCellToken.
 364     ScMatrixFormulaCellToken* pMatFormula = GetMatrixFormulaCellTokenNonConst();
 365     if (pMatFormula)
 366         pMatFormula->SetUpperLeftDouble( f);
 367     else
 368     {
 369         if (mbToken && mpToken)
 370             mpToken->DecRef();
 371         mfValue = f;
 372         mbToken = false;
 373         meMultiline = MULTILINE_FALSE;
 374     }
 375 }
 376
 377
 378 inline formula::StackVar ScFormulaResult::GetType() const
 379 {
 380     // Order is significant.
 381     if (mnError)
 382         return formula::svError;
 383     if (mbEmpty)
 384         return formula::svEmptyCell;
 385     if (!mbToken)
 386         return formula::svDouble;
 387     if (mpToken)
 388         return mpToken->GetType();
 389     return formula::svUnknown;
 390 }
 391
 392
 393 inline formula::StackVar ScFormulaResult::GetCellResultType() const
 394 {
 395     formula::StackVar sv = GetType();
 396     if (sv == formula::svMatrixCell)
 397         // don't need to test for mpToken here, GetType() already did it
 398         sv = static_cast<const ScMatrixCellResultToken*>(mpToken)->GetUpperLeftType();
 399     return sv;
 400 }
 401
 402
 403 inline bool ScFormulaResult::IsEmptyDisplayedAsString() const
 404 {
 405     if (mbEmpty)
 406         return mbEmptyDisplayedAsString;
 407     if (GetType() == formula::svMatrixCell)
 408     {
 409         // don't need to test for mpToken here, GetType() already did it
 410         const ScEmptyCellToken* p = dynamic_cast<const ScEmptyCellToken*>(
 411                 static_cast<const ScMatrixCellResultToken*>(
 412                     mpToken)->GetUpperLeftToken().operator->());
 413         if (p)
 414             return p->IsDisplayedAsString();
 415     }
 416     return false;
 417 }
 418
 419
 420 inline bool ScFormulaResult::IsValue() const
 421 {
 422     formula::StackVar sv = GetCellResultType();
 423     return sv == formula::svDouble || sv == formula::svError || sv == formula::svEmptyCell;
 424 }
 425
 426 inline bool ScFormulaResult::IsMultiline() const
 427 {
 428     if (meMultiline == MULTILINE_UNKNOWN)
 429     {
 430         const String& rStr = GetString();
 431         if (rStr.Len() && rStr.Search( _LF ) != STRING_NOTFOUND)
 432             const_cast<ScFormulaResult*>(this)->meMultiline = MULTILINE_TRUE;
 433         else
 434             const_cast<ScFormulaResult*>(this)->meMultiline = MULTILINE_FALSE;
 435     }
 436     return meMultiline == MULTILINE_TRUE;
 437 }
 438
 439
 440 inline USHORT ScFormulaResult::GetResultError() const
 441 {
 442     if (mnError)
 443         return mnError;
 444     formula::StackVar sv = GetCellResultType();
 445     if (sv == formula::svError)
 446     {
 447         if (GetType() == formula::svMatrixCell)
 448             // don't need to test for mpToken here, GetType() already did it
 449             return static_cast<const ScMatrixCellResultToken*>(mpToken)->
 450                 GetUpperLeftToken()->GetError();
 451         if (mpToken)
 452             return mpToken->GetError();
 453     }
 454     return 0;
 455 }
 456
 457
 458 inline void ScFormulaResult::SetResultError( USHORT nErr )
 459 {
 460     mnError = nErr;
 461 }
 462
 463
 464 inline formula::FormulaConstTokenRef ScFormulaResult::GetToken() const
 465 {
 466     if (mbToken)
 467         return mpToken;
 468     return NULL;
 469 }
 470
 471
 472 inline formula::FormulaConstTokenRef ScFormulaResult::GetCellResultToken() const
 473 {
 474     if (GetType() == formula::svMatrixCell)
 475         // don't need to test for mpToken here, GetType() already did it
 476         return static_cast<const ScMatrixCellResultToken*>(mpToken)->GetUpperLeftToken();
 477     return GetToken();
 478 }
 479
 480
 481 inline double ScFormulaResult::GetDouble() const
 482 {
 483     if (mbToken)
 484     {
 485         // Should really not be of type formula::svDouble here.
 486         if (mpToken)
 487         {
 488             switch (mpToken->GetType())
 489             {
 490                 case formula::svHybridCell:
 491                     return mpToken->GetDouble();
 492                 case formula::svMatrixCell:
 493                     {
 494                         const ScMatrixCellResultToken* p =
 495                             static_cast<const ScMatrixCellResultToken*>(mpToken);
 496                         if (p->GetUpperLeftType() == formula::svDouble)
 497                             return p->GetUpperLeftToken()->GetDouble();
 498                     }
 499                     break;
 500                 default:
 501                     ;   // nothing
 502             }
 503         }
 504         return 0.0;
 505     }
 506     if (mbEmpty)
 507         return 0.0;
 508     return mfValue;
 509 }
 510
 511
 512 inline const String & ScFormulaResult::GetString() const
 513 {
 514     if (mbToken && mpToken)
 515     {
 516         switch (mpToken->GetType())
 517         {
 518             case formula::svString:
 519             case formula::svHybridCell:
 520                 return mpToken->GetString();
 521             case formula::svMatrixCell:
 522                 {
 523                     const ScMatrixCellResultToken* p =
 524                         static_cast<const ScMatrixCellResultToken*>(mpToken);
 525                     if (p->GetUpperLeftType() == formula::svString)
 526                         return p->GetUpperLeftToken()->GetString();
 527                 }
 528                 break;
 529             default:
 530                 ;   // nothing
 531         }
 532     }
 533     return EMPTY_STRING;
 534 }
 535
 536
 537 inline ScConstMatrixRef ScFormulaResult::GetMatrix() const
 538 {
 539     if (GetType() == formula::svMatrixCell)
 540         return static_cast<const ScToken*>(mpToken)->GetMatrix();
 541     return NULL;
 542 }
 543
 544
 545 inline const String & ScFormulaResult::GetHybridFormula() const
 546 {
 547     if (GetType() == formula::svHybridCell)
 548     {
 549         const ScHybridCellToken* p = dynamic_cast<const ScHybridCellToken*>(mpToken);
 550         if (p)
 551             return p->GetFormula();
 552     }
 553     return EMPTY_STRING;
 554 }
 555
 556
 557 inline void ScFormulaResult::SetHybridDouble( double f )
 558 {
 559     ResetToDefaults();
 560     if (mbToken && mpToken)
 561     {
 562         String aString( GetString());
 563         String aFormula( GetHybridFormula());
 564         mpToken->DecRef();
 565         mpToken = new ScHybridCellToken( f, aString, aFormula);
 566         mpToken->IncRef();
 567     }
 568     else
 569     {
 570         mfValue = f;
 571         mbToken = false;
 572         meMultiline = MULTILINE_FALSE;
 573     }
 574 }
 575
 576
 577 inline void ScFormulaResult::SetHybridString( const String & rStr )
 578 {
 579     // Obtain values before changing anything.
 580     double f = GetDouble();
 581     String aFormula( GetHybridFormula());
 582     ResetToDefaults();
 583     if (mbToken && mpToken)
 584         mpToken->DecRef();
 585     mpToken = new ScHybridCellToken( f, rStr, aFormula);
 586     mpToken->IncRef();
 587     mbToken = true;
 588 }
 589
 590
 591 inline void ScFormulaResult::SetHybridFormula( const String & rFormula )
 592 {
 593     // Obtain values before changing anything.
 594     double f = GetDouble();
 595     String aStr( GetString());
 596     ResetToDefaults();
 597     if (mbToken && mpToken)
 598         mpToken->DecRef();
 599     mpToken = new ScHybridCellToken( f, aStr, rFormula);
 600     mpToken->IncRef();
 601     mbToken = true;
 602 }
 603
 604
 605 inline const ScMatrixFormulaCellToken* ScFormulaResult::GetMatrixFormulaCellToken() const
 606 {
 607     return (GetType() == formula::svMatrixCell ?
 608             dynamic_cast<const ScMatrixFormulaCellToken*>(mpToken) : NULL);
 609 }
 610
 611
 612 inline ScMatrixFormulaCellToken* ScFormulaResult::GetMatrixFormulaCellTokenNonConst()
 613 {
 614     return const_cast<ScMatrixFormulaCellToken*>( GetMatrixFormulaCellToken());
 615 }
 616
 617
 618 #endif // SC_FORMULARESULT_HXX