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