sc/inc/cellvalue.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
  10 #ifndef INCLUDED_SC_INC_CELLVALUE_HXX
  11 #define INCLUDED_SC_INC_CELLVALUE_HXX
  12
  13 #include "global.hxx"
  14
  15 class ScDocument;
  16 class ScFormulaCell;
  17 class EditTextObject;
  18 class ScColumn;
  19 struct ScRefCellValue;
  20
  21 namespace svl {
  22
  23 class SharedString;
  24
  25 }
  26
  27 /**
  28  * Store arbitrary cell value of any kind.  It only stores cell value and
  29  * nothing else.  It creates a copy of the original cell value, and manages
  30  * the life cycle of the copied value.
  31  */
  32 struct SC_DLLPUBLIC ScCellValue
  33 {
  34     CellType meType;
  35     union {
  36         double mfValue;
  37         svl::SharedString* mpString;
  38         EditTextObject* mpEditText;
  39         ScFormulaCell* mpFormula;
  40     };
  41
  42     ScCellValue();
  43     ScCellValue( const ScRefCellValue& rCell );
  44     ScCellValue( double fValue );
  45     ScCellValue( const svl::SharedString& rString );
  46     ScCellValue( const ScCellValue& r );
  47     ScCellValue( ScCellValue&& r );
  48     ~ScCellValue();
  49
  50     void clear();
  51
  52     void set( double fValue );
  53     void set( const svl::SharedString& rStr );
  54     void set( const EditTextObject& rEditText );
  55     void set( EditTextObject* pEditText );
  56     void set( ScFormulaCell* pFormula );
  57
  58     /**
  59      * Take cell value from specified position in specified document.
  60      */
  61     void assign( const ScDocument& rDoc, const ScAddress& rPos );
  62
  63     void assign(const ScCellValue& rOther, ScDocument& rDestDoc, ScCloneFlags nCloneFlags = ScCloneFlags::Default);
  64
  65     /**
  66      * Set cell value at specified position in specified document.
  67      */
  68     void commit( ScDocument& rDoc, const ScAddress& rPos ) const;
  69
  70     void commit( ScColumn& rColumn, SCROW nRow ) const;
  71
  72     /**
  73      * Set cell value at specified position in specified document. But unlike
  74      * commit(), this method sets the original value to the document without
  75      * copying.  After this call, the value gets cleared.
  76      */
  77     void release( ScDocument& rDoc, const ScAddress& rPos );
  78
  79     void release( ScColumn& rColumn, SCROW nRow, sc::StartListeningType eListenType = sc::SingleCellListening );
  80
  81     OUString getString( const ScDocument* pDoc );
  82
  83     bool isEmpty() const;
  84
  85     bool equalsWithoutFormat( const ScCellValue& r ) const;
  86
  87     ScCellValue& operator= ( const ScCellValue& r );
  88     ScCellValue& operator= ( ScCellValue&& r );
  89     ScCellValue& operator= ( const ScRefCellValue& r );
  90
  91     void swap( ScCellValue& r );
  92 };
  93
  94 /**
  95  * This is very similar to ScCellValue, except that it references the
  96  * original value instead of copying it.  As such, don't hold an instance of
  97  * this class any longer than necessary, and absolutely not after the
  98  * original cell has been destroyed.
  99  */
 100 struct SC_DLLPUBLIC ScRefCellValue
 101 {
 102     CellType meType;
 103     union {
 104         double mfValue;
 105         const svl::SharedString* mpString;
 106         const EditTextObject* mpEditText;
 107         ScFormulaCell* mpFormula;
 108     };
 109
 110     ScRefCellValue();
 111     ScRefCellValue( double fValue );
 112     ScRefCellValue( const svl::SharedString* pString );
 113     ScRefCellValue( const EditTextObject* pEditText );
 114     ScRefCellValue( ScFormulaCell* pFormula );
 115
 116     /**
 117      * Take cell value from specified position in specified document.
 118      */
 119     ScRefCellValue( ScDocument& rDoc, const ScAddress& rPos );
 120
 121     void clear();
 122
 123     /**
 124      * Take cell value from specified position in specified document.
 125      */
 126     void assign( ScDocument& rDoc, const ScAddress& rPos );
 127
 128     /**
 129      * Set cell value at specified position in specified document.
 130      */
 131     void commit( ScDocument& rDoc, const ScAddress& rPos ) const;
 132
 133     bool hasString() const;
 134
 135     bool hasNumeric() const;
 136
 137     bool hasError() const;
 138
 139     double getValue();
 140
 141     /**
 142      * Retrieve a numeric value without modifying the states of any objects in
 143      * the referenced document store.
 144      */
 145     double getRawValue() const;
 146
 147     /**
 148      *  Retrieve string value.
 149      *
 150      *  Note that this method is NOT thread-safe.
 151      *
 152      *  @param  pDoc
 153      *          Needed to resolve EditCells' field contents, obtain a
 154      *          ScFieldEditEngine from that document. May be NULL if there is
 155      *          no ScDocument in the calling context but then the document
 156      *          specific fields can not be resolved. See
 157      *          ScEditUtil::GetString().
 158      */
 159     OUString getString( const ScDocument* pDoc );
 160
 161     /**
 162      * Retrieve a string value without modifying the states of any objects in
 163      * the referenced document store.
 164      *
 165      * This method is thread-safe.
 166      */
 167     OUString getRawString( const ScDocument* pDoc ) const;
 168
 169     bool isEmpty() const;
 170
 171     bool hasEmptyValue();
 172
 173     bool equalsWithoutFormat( const ScRefCellValue& r ) const;
 174 };
 175
 176 #endif
 177
 178 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */