Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 193 insertions, 0 deletions

diff --git a/sc/inc/cellvalue.hxx b/sc/inc/cellvalue.hxx
new file mode 100644
index 0000000000..6db9dee493
--- /dev/null
+++ b/sc/inc/cellvalue.hxx
@@ -0,0 +1,193 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "global.hxx"
+#include <svl/sharedstring.hxx>
+#include <variant>
+
+class ScDocument;
+class ScFormulaCell;
+class EditTextObject;
+class ScColumn;
+struct ScRefCellValue;
+
+namespace sc {
+struct ColumnBlockPosition;
+}
+
+/**
+ * Store arbitrary cell value of any kind.  It only stores cell value and
+ * nothing else.  It creates a copy of the original cell value, and manages
+ * the life cycle of the copied value.
+ */
+struct SC_DLLPUBLIC ScCellValue
+{
+private:
+    /// std::monostate is there to indicate CellType::NONE
+    std::variant<std::monostate, double, svl::SharedString, EditTextObject*, ScFormulaCell*> maData;
+
+    void reset_to_empty();
+public:
+
+    ScCellValue();
+    ScCellValue( const ScRefCellValue& rCell );
+    ScCellValue( double fValue );
+    ScCellValue( const svl::SharedString& rString );
+    ScCellValue( std::unique_ptr<EditTextObject> );
+    ScCellValue( const ScCellValue& r );
+    ScCellValue(ScCellValue&& r) noexcept;
+    ~ScCellValue();
+
+    void clear() noexcept;
+
+    void set( double fValue );
+    void set( const svl::SharedString& rStr );
+    void set( const EditTextObject& rEditText );
+    void set( std::unique_ptr<EditTextObject> );
+    void set( ScFormulaCell* pFormula );
+
+    CellType getType() const;
+    double getDouble() const { return std::get<double>(maData); }
+    ScFormulaCell* getFormula() const { return std::get<ScFormulaCell*>(maData); }
+    const svl::SharedString* getSharedString() const { return &std::get<svl::SharedString>(maData); }
+    EditTextObject* getEditText() const { return std::get<EditTextObject*>(maData); }
+    EditTextObject* releaseEditText() { auto p = getEditText(); maData = static_cast<EditTextObject*>(nullptr); return p; }
+    ScFormulaCell* releaseFormula() { auto p = getFormula(); maData = static_cast<ScFormulaCell*>(nullptr); return p; }
+
+    /**
+     * Take cell value from specified position in specified document.
+     */
+    void assign( const ScDocument& rDoc, const ScAddress& rPos );
+
+    void assign(const ScCellValue& rOther, ScDocument& rDestDoc, ScCloneFlags nCloneFlags = ScCloneFlags::Default);
+
+    /**
+     * Set cell value at specified position in specified document.
+     */
+    void commit( ScDocument& rDoc, const ScAddress& rPos ) const;
+
+    void commit( ScColumn& rColumn, SCROW nRow ) const;
+
+    /**
+     * Set cell value at specified position in specified document. But unlike
+     * commit(), this method sets the original value to the document without
+     * copying.  After this call, the value gets cleared.
+     */
+    void release( ScDocument& rDoc, const ScAddress& rPos );
+
+    void release( ScColumn& rColumn, SCROW nRow, sc::StartListeningType eListenType = sc::SingleCellListening );
+
+    OUString getString( const ScDocument& rDoc ) const;
+
+    bool isEmpty() const;
+
+    bool equalsWithoutFormat( const ScCellValue& r ) const;
+
+    ScCellValue& operator= ( const ScCellValue& r );
+    ScCellValue& operator=(ScCellValue&& r) noexcept;
+    ScCellValue& operator= ( const ScRefCellValue& r );
+
+    void swap( ScCellValue& r );
+};
+
+/**
+ * This is very similar to ScCellValue, except that it references the
+ * original value instead of copying it.  As such, don't hold an instance of
+ * this class any longer than necessary, and absolutely not after the
+ * original cell has been destroyed.
+ */
+struct SC_DLLPUBLIC ScRefCellValue
+{
+private:
+    CellType meType;
+    union {
+        double mfValue;
+        const svl::SharedString* mpString;
+        const EditTextObject* mpEditText;
+        ScFormulaCell* mpFormula;
+    };
+public:
+
+    ScRefCellValue();
+    ScRefCellValue( double fValue );
+    ScRefCellValue( const svl::SharedString* pString );
+    ScRefCellValue( const EditTextObject* pEditText );
+    ScRefCellValue( ScFormulaCell* pFormula );
+
+    /**
+     * Take cell value from specified position in specified document.
+     */
+    ScRefCellValue( ScDocument& rDoc, const ScAddress& rPos );
+    ScRefCellValue( ScDocument& rDoc, const ScAddress& rPos, sc::ColumnBlockPosition& rBlockPos );
+
+    void clear();
+
+    CellType getType() const { return meType; }
+    double getDouble() const { assert(meType == CELLTYPE_VALUE); return mfValue; }
+    const svl::SharedString* getSharedString() const { assert(meType == CELLTYPE_STRING); return mpString; }
+    const EditTextObject* getEditText() const { assert(meType == CELLTYPE_EDIT); return mpEditText; }
+    ScFormulaCell* getFormula() const { assert(meType == CELLTYPE_FORMULA); return mpFormula; }
+
+    /**
+     * Take cell value from specified position in specified document.
+     */
+    void assign( ScDocument& rDoc, const ScAddress& rPos );
+    void assign( ScDocument& rDoc, const ScAddress& rPos, sc::ColumnBlockPosition& rBlockPos );
+
+    /**
+     * Set cell value at specified position in specified document.
+     */
+    void commit( ScDocument& rDoc, const ScAddress& rPos ) const;
+
+    bool hasString() const;
+
+    bool hasNumeric() const;
+
+    bool hasError() const;
+
+    double getValue();
+
+    /**
+     * Retrieve a numeric value without modifying the states of any objects in
+     * the referenced document store.
+     */
+    double getRawValue() const;
+
+    /**
+     *  Retrieve string value.
+     *
+     *  Note that this method is NOT thread-safe.
+     *
+     *  @param  pDoc
+     *          Needed to resolve EditCells' field contents, obtain a
+     *          ScFieldEditEngine from that document. May be NULL if there is
+     *          no ScDocument in the calling context but then the document
+     *          specific fields can not be resolved. See
+     *          ScEditUtil::GetString().
+     */
+    OUString getString( const ScDocument* pDoc ) const;
+
+    /**
+     * Retrieve a string value without modifying the states of any objects in
+     * the referenced document store.
+     *
+     * This method is thread-safe.
+     */
+    OUString getRawString( const ScDocument& rDoc ) const;
+
+    bool isEmpty() const;
+
+    bool hasEmptyValue();
+
+    bool equalsWithoutFormat( const ScRefCellValue& r ) const;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */