sc/source/core/data/mtvelements.cxx

   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 #include <mtvelements.hxx>
  11 #include <document.hxx>
  12 #include <cellvalue.hxx>
  13 #include <column.hxx>
  14 #include <table.hxx>
  15
  16 #include <sstream>
  17
  18 namespace sc {
  19
  20 CellStoreEvent::CellStoreEvent() : mpCol(nullptr) {}
  21
  22 CellStoreEvent::CellStoreEvent(ScColumn* pCol) : mpCol(pCol) {}
  23
  24 void CellStoreEvent::element_block_acquired(const mdds::mtv::base_element_block* block)
  25 {
  26     if (!mpCol)
  27         return;
  28
  29     switch (mdds::mtv::get_block_type(*block))
  30     {
  31         case sc::element_type_formula:
  32             ++mpCol->mnBlkCountFormula;
  33             break;
  34         case sc::element_type_cellnote:
  35             ++mpCol->mnBlkCountCellNotes;
  36             break;
  37         default:
  38             ;
  39     }
  40 }
  41
  42 void CellStoreEvent::element_block_released(const mdds::mtv::base_element_block* block)
  43 {
  44     if (!mpCol)
  45         return;
  46
  47     switch (mdds::mtv::get_block_type(*block))
  48     {
  49         case sc::element_type_formula:
  50             --mpCol->mnBlkCountFormula;
  51             break;
  52         case sc::element_type_cellnote:
  53             --mpCol->mnBlkCountCellNotes;
  54             break;
  55         default:
  56             ;
  57     }
  58 }
  59
  60 void CellStoreEvent::stop()
  61 {
  62     mpCol = nullptr;
  63 }
  64
  65 void CellStoreEvent::swap(CellStoreEvent& other)
  66 {
  67     std::swap(mpCol, other.mpCol);
  68 }
  69
  70 const ScColumn* CellStoreEvent::getColumn() const
  71 {
  72     return mpCol;
  73 }
  74
  75 ColumnBlockPositionSet::ColumnBlockPositionSet(ScDocument& rDoc) : mrDoc(rDoc) {}
  76
  77 ColumnBlockPosition* ColumnBlockPositionSet::getBlockPosition(SCTAB nTab, SCCOL nCol)
  78 {
  79     std::scoped_lock aGuard(maMtxTables);
  80
  81     TablesType::iterator itTab = maTables.find(nTab);
  82     if (itTab == maTables.end())
  83     {
  84         std::pair<TablesType::iterator,bool> r =
  85             maTables.emplace(nTab, ColumnsType());
  86         if (!r.second)
  87             // insertion failed.
  88             return nullptr;
  89
  90         itTab = r.first;
  91     }
  92
  93     ColumnsType& rCols = itTab->second;
  94
  95     ColumnsType::iterator it = rCols.find(nCol);
  96     if (it != rCols.end())
  97         // Block position for this column has already been fetched.
  98         return &it->second;
  99
 100     std::pair<ColumnsType::iterator,bool> r =
 101         rCols.emplace(nCol, ColumnBlockPosition());
 102
 103     if (!r.second)
 104         // insertion failed.
 105         return nullptr;
 106
 107     it = r.first;
 108
 109     if (!mrDoc.InitColumnBlockPosition(it->second, nTab, nCol))
 110         return nullptr;
 111
 112     return &it->second;
 113 }
 114
 115 void ColumnBlockPositionSet::clear()
 116 {
 117     std::scoped_lock aGuard(maMtxTables);
 118     maTables.clear();
 119 }
 120
 121 struct TableColumnBlockPositionSet::Impl
 122 {
 123     typedef std::unordered_map<SCCOL, ColumnBlockPosition> ColumnsType;
 124
 125     ScTable* mpTab;
 126     ColumnsType maColumns;
 127
 128     Impl() : mpTab(nullptr) {}
 129 };
 130
 131 TableColumnBlockPositionSet::TableColumnBlockPositionSet( ScDocument& rDoc, SCTAB nTab ) :
 132     mpImpl(std::make_unique<Impl>())
 133 {
 134     mpImpl->mpTab = rDoc.FetchTable(nTab);
 135
 136     if (!mpImpl->mpTab)
 137     {
 138         std::ostringstream os;
 139         os << "Passed table index " << nTab << " is invalid.";
 140         throw std::invalid_argument(os.str());
 141     }
 142 }
 143
 144 TableColumnBlockPositionSet::TableColumnBlockPositionSet( TableColumnBlockPositionSet&& rOther ) noexcept :
 145     mpImpl(std::move(rOther.mpImpl)) {}
 146
 147 TableColumnBlockPositionSet::~TableColumnBlockPositionSet() {}
 148
 149 ColumnBlockPosition* TableColumnBlockPositionSet::getBlockPosition( SCCOL nCol )
 150 {
 151     using ColumnsType = Impl::ColumnsType;
 152
 153     ColumnsType::iterator it = mpImpl->maColumns.find(nCol);
 154
 155     if (it != mpImpl->maColumns.end())
 156         // Block position for this column has already been fetched.
 157         return &it->second;
 158
 159     std::pair<ColumnsType::iterator,bool> r =
 160         mpImpl->maColumns.emplace(nCol, ColumnBlockPosition());
 161
 162     if (!r.second)
 163         // insertion failed.
 164         return nullptr;
 165
 166     it = r.first;
 167
 168     if (!mpImpl->mpTab->InitColumnBlockPosition(it->second, nCol))
 169         return nullptr;
 170
 171     return &it->second;
 172 }
 173
 174 void TableColumnBlockPositionSet::invalidate()
 175 {
 176     mpImpl->maColumns.clear();
 177 }
 178
 179 ScRefCellValue toRefCell( const sc::CellStoreType::const_iterator& itPos, size_t nOffset )
 180 {
 181     switch (itPos->type)
 182     {
 183         case sc::element_type_numeric:
 184             // Numeric cell
 185             return ScRefCellValue(sc::numeric_block::get_value(*itPos->data, nOffset));
 186         case sc::element_type_string:
 187             // String cell
 188             return ScRefCellValue(&sc::string_block::at(*itPos->data, nOffset));
 189         case sc::element_type_edittext:
 190             // Edit cell
 191             return ScRefCellValue(sc::edittext_block::get_value(*itPos->data, nOffset));
 192         case sc::element_type_formula:
 193             // Formula cell
 194             return ScRefCellValue(sc::formula_block::get_value(*itPos->data, nOffset));
 195         default:
 196             ;
 197     }
 198
 199     return ScRefCellValue();
 200 }
 201
 202 }
 203
 204 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */