sc/inc/formularesult.hxx

   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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SC_INC_FORMULARESULT_HXX
  21 #define INCLUDED_SC_INC_FORMULARESULT_HXX
  22
  23 #include "scdllapi.h"
  24 #include "global.hxx"
  25 #include "calcmacros.hxx"
  26 #include <svl/sharedstring.hxx>
  27 #include <formula/token.hxx>
  28 #include <formula/types.hxx>
  29
  30 class ScMatrixFormulaCellToken;
  31
  32 namespace sc {
  33
  34 struct FormulaResultValue
  35 {
  36     enum Type : sal_uInt8 { Invalid, Value, String, Error };
  37
  38     double mfValue;
  39     svl::SharedString maString;
  40     Type meType;
  41     FormulaError mnError;
  42
  43     FormulaResultValue();
  44     FormulaResultValue( double fValue );
  45     FormulaResultValue( const svl::SharedString& rStr );
  46     FormulaResultValue( FormulaError nErr );
  47 };
  48
  49 }
  50
  51 /** Store a variable formula cell result, balancing between runtime performance
  52     and memory consumption. */
  53 class ScFormulaResult
  54 {
  55     typedef unsigned char Multiline;
  56     static const Multiline MULTILINE_UNKNOWN = 0;
  57     static const Multiline MULTILINE_FALSE   = 1;
  58     static const Multiline MULTILINE_TRUE    = 2;
  59
  60     // Clone token if the 16-bit only reference counter is nearing it's
  61     // capacity during fill or copy&paste, leaving 4k for temporary passing
  62     // around. (That should be enough for all times (TM) ;-)
  63     static const sal_uInt16 MAX_TOKENREF_COUNT = 0xf000;
  64     static void IncrementTokenRef( const formula::FormulaToken* & rp )
  65     {
  66         if (rp)
  67         {
  68             if (rp->GetRef() >= MAX_TOKENREF_COUNT)
  69                 rp = rp->Clone();
  70             rp->IncRef();
  71         }
  72     }
  73
  74     union
  75     {
  76         double          mfValue;    // double result direct for performance and memory consumption
  77         const formula::FormulaToken*  mpToken;    // if not, result token obtained from interpreter
  78     };
  79     bool                mbToken :1; // whether content of union is a token
  80     bool                mbEmpty :1; // empty cell result
  81     bool                mbEmptyDisplayedAsString :1;    // only if mbEmpty
  82     // If set it implies that the result is a simple double (in mfValue) and no error
  83     bool                mbValueCached :1;
  84     Multiline           meMultiline :2; // result is multiline
  85     FormulaError        mnError;    // error code
  86
  87     /** Reset mnError, mbEmpty and mbEmptyDisplayedAsString to their defaults
  88         prior to assigning other types */
  89     void ResetToDefaults();
  90
  91     /** If token is of formula::svError set error code and decrement RefCount.
  92         If token is of formula::svEmptyCell set mbEmpty and mbEmptyAsString and
  93         decrement RefCount.
  94         If token is of formula::svDouble set mfValue and decrement RefCount.
  95         Else assign token to mpToken. NULL is valid => svUnknown.
  96         Other member variables are set accordingly.
  97         @precondition: Token MUST had been IncRef'ed prior to this call!
  98         @precondition: An already existing different mpToken MUST had been
  99         DecRef'ed prior to this call, p will be assigned to mpToken if not
 100         resolved.
 101         ATTENTION! Token may get deleted in this call! */
 102     void ResolveToken( const formula::FormulaToken * p );
 103
 104 public:
 105     /** Effectively type svUnknown. */
 106     ScFormulaResult();
 107
 108     ScFormulaResult( const ScFormulaResult & r );
 109
 110     /** Same comments as for SetToken() apply! */
 111     explicit ScFormulaResult( const formula::FormulaToken* p );
 112
 113     ~ScFormulaResult();
 114
 115     /** Well, guess what ... */
 116     ScFormulaResult& operator=( const ScFormulaResult & r );
 117
 118     /** Assignment as in operator=() but without return */
 119     void Assign( const ScFormulaResult & r );
 120
 121     /** Sets a direct double if token type is formula::svDouble, or mbEmpty if
 122         formula::svEmptyCell, else token. If p is NULL, that is set as well, effectively
 123         resulting in GetType()==svUnknown. If the already existing result is
 124         ScMatrixFormulaCellToken, the upper left is set to token.
 125
 126         ATTENTION! formula::FormulaToken had to be allocated using 'new' and if of type
 127         formula::svDouble and no RefCount was set may not be used after this call
 128         because it was deleted after decrement! */
 129     void SetToken( const formula::FormulaToken* p );
 130
 131     /** May be NULL if SetToken() did so, also if type formula::svDouble or formula::svError! */
 132     formula::FormulaConstTokenRef GetToken() const;
 133
 134     /** Return upper left token if formula::svMatrixCell, else return GetToken().
 135         May be NULL if SetToken() did so, also if type formula::svDouble or formula::svError! */
 136     formula::FormulaConstTokenRef GetCellResultToken() const;
 137
 138     /** Return type of result, including formula::svError, formula::svEmptyCell, formula::svDouble and
 139         formula::svMatrixCell. */
 140     formula::StackVar GetType() const;
 141
 142     /** If type is formula::svMatrixCell return the type of upper left element, else
 143         GetType() */
 144     formula::StackVar GetCellResultType() const;
 145
 146     /** If type is formula::svEmptyCell (including matrix upper left) and should be
 147         displayed as empty string */
 148     bool IsEmptyDisplayedAsString() const;
 149
 150     /** Test for cell result type formula::svDouble, including upper left if
 151         formula::svMatrixCell. Also included is formula::svError for legacy, because previously
 152         an error result was treated like a numeric value at some places in
 153         ScFormulaCell. Also included is formula::svEmptyCell as a reference to an empty
 154         cell usually is treated as numeric 0. Use GetCellResultType() for
 155         details instead. */
 156     bool IsValue() const;
 157
 158     bool IsValueNoError() const;
 159
 160     /** Determines whether or not the result is a string containing more than
 161         one paragraph */
 162     bool IsMultiline() const;
 163
 164     bool GetErrorOrDouble( FormulaError& rErr, double& rVal ) const;
 165     sc::FormulaResultValue GetResult() const;
 166
 167     /** Get error code if set or GetCellResultType() is formula::svError or svUnknown,
 168         else 0. */
 169     FormulaError GetResultError() const;
 170
 171     /** Set error code, don't touch token or double. */
 172     void SetResultError( FormulaError nErr );
 173
 174     /** Set direct double. Shouldn't be used externally except in
 175         ScFormulaCell for rounded CalcAsShown or SetErrCode() or
 176         SetResultDouble(), see there for condition. If
 177         ScMatrixFormulaCellToken the token isn't replaced but upper
 178         left result is modified instead, but only if it was of type
 179         formula::svDouble before or not set at all.
 180      */
 181     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     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     svl::SharedString GetString() const;
 190
 191     /** Return matrix if type formula::svMatrixCell and ScMatrix present, else NULL. */
 192     ScConstMatrixRef GetMatrix() const;
 193
 194     /** Return formula string if type formula::svHybridCell, else empty string. */
 195     const OUString& GetHybridFormula() const;
 196
 197     /** Should only be used by import filters, best in the order
 198         SetHybridDouble(), SetHybridString(), or only SetHybridFormula() for
 199         formula string to be compiled later. */
 200     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     void SetHybridString( const svl::SharedString & rStr );
 206
 207     /** Should only be used by import filters, best in the order
 208         SetHybridDouble(), SetHybridFormula(),
 209         SetHybridEmptyDisplayedAsString() must be last. */
 210     void SetHybridEmptyDisplayedAsString();
 211
 212     /** Should only be used by import filters, best in the order
 213         SetHybridDouble(), SetHybridString()/SetHybridFormula(), or only
 214         SetHybridFormula() for formula string to be compiled later. */
 215     void SetHybridFormula( const OUString & rFormula );
 216
 217     void SetMatrix( SCCOL nCols, SCROW nRows, const ScConstMatrixRef& pMat, const formula::FormulaToken* pUL );
 218
 219     /** Get the const ScMatrixFormulaCellToken* if token is of that type, else
 220         NULL. */
 221     const ScMatrixFormulaCellToken* GetMatrixFormulaCellToken() const;
 222
 223     /** Get the ScMatrixFormulaCellToken* if token is of that type, else NULL.
 224         Shouldn't be used externally except by ScFormulaCell::SetMatColsRows(). */
 225     ScMatrixFormulaCellToken* GetMatrixFormulaCellTokenNonConst();
 226 };
 227
 228 #endif // INCLUDED_SC_INC_FORMULARESULT_HXX
 229
 230 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */