24 #include <document.hxx>
33 #include <progress.hxx>
36 #include <globstr.hrc>
51 using ::rtl::math::approxEqual;
57 #define debugiter(...)
61 template<
typename Iter>
62 void incBlock(std::pair<Iter, size_t>& rPos)
69 template<
typename Iter>
70 void decBlock(std::pair<Iter, size_t>& rPos)
74 rPos.second = rPos.first->size - 1;
83 if ( rpArr == pNewArr && nAttrEndRow >= nRow )
97 nAttrEndRow = nRowEnd;
104 , pAttrArray(nullptr)
107 , maStartPos(rRange.aStart)
108 , maEndPos(rRange.aEnd)
112 , mnSubTotalFlags(nSubTotalFlags)
115 , bCalcAsShown(rDocument.GetDocOptions().IsCalcAsShown())
116 , bTextAsZero(bTextZero)
178 rErr = FormulaError::NONE;
208 rErr = FormulaError::NONE;
252 rErr = FormulaError::NONE;
299 if (nCol < pTab->GetAllocatedColumnsCount())
330 return &pTab->
aCol[nCol].maCells;
337 return pCol->pAttrArray.get();
344 return rDoc.
maTabs[nTab]->ValidQuery(nRow, rParam, pCell);
353 , pAttrArray(nullptr)
361 , bCalcAsShown(rDoc.GetDocOptions().IsCalcAsShown())
394 if (maCurPos.first == mpCells->end() || nRow >
mpParam->nRow2)
397 rValue.
mnError = FormulaError::NONE;
409 if (nCol == static_cast<SCCOL>(nFirstQueryField))
430 nAttrEndRow, pNewAttrArray, nRow, mrDoc );
431 rValue.
mfValue = mrDoc.RoundValueAsShown( rValue.
mfValue, nNumFormat );
433 nNumFmtType = SvNumFormatType::NUMBER;
435 rValue.
mnError = FormulaError::NONE;
445 mrDoc.GetNumberFormatInfo(
470 rValue.
mnError = FormulaError::NONE;
494 maCurPos = mpCells->position(nRow);
495 return getCurrent(rValue);
500 if (!mpCells || maCurPos.first == mpCells->end())
504 return getCurrent(rValue);
512 nRow = maCurPos.first->position;
517 if (maCurPos.second + 1 < maCurPos.first->size)
546 for ( ;mnCurRow < mnRows; ++mnCurRow)
554 if (bIsStrVal &&
mpParam->mbSkipString)
557 if (isValidQuery(mnCurRow, rMat))
562 rValue.
mnError = FormulaError::NONE;
571 mnCurRow =
mpParam->bHasHeader ? 1 : 0;
572 return getCurrent(rValue);
578 return getCurrent(rValue);
619 vector<bool> aResults;
620 aResults.reserve(nEntryCount);
649 if (isQueryByValue(rItem, rMat, nField, nRow))
652 double fMatVal = rMat.
GetDouble(nField, nRow);
653 bool bEqual = approxEqual(fMatVal, rItem.
mfVal);
660 bValid = (fMatVal < rItem.
mfVal) && !bEqual;
663 bValid = (fMatVal > rItem.
mfVal) && !bEqual;
666 bValid = (fMatVal < rItem.
mfVal) || bEqual;
669 bValid = (fMatVal > rItem.
mfVal) || bEqual;
678 else if (isQueryByString(rEntry, rItem, rMat, nField, nRow))
711 bValid = (nCompare < 0);
714 bValid = (nCompare > 0);
717 bValid = (nCompare <= 0);
720 bValid = (nCompare >= 0);
729 if (aResults.empty())
731 aResults.push_back(bValid);
735 size_t n = aResults.size();
736 aResults[n-1] = aResults[n-1] && bValid;
740 aResults.push_back(bValid);
744 return std::find(aResults.begin(), aResults.end(),
true) != aResults.end();
774 return mpData->getFirst(rValue);
779 return mpData->getNext(rValue);
836 maStartPos(rRange.aStart),
837 maEndPos(rRange.aEnd),
838 mnSubTotalFlags(nSubTotalFlags)
896 assert(!
"Table not found");
1054 nStopOnMismatch( nStopOnMismatchDisabled ),
1055 nTestEqualCondition( nTestEqualConditionDisabled ),
1056 bAdvanceQuery( false ),
1057 bIgnoreMismatchOnLeadingStrings( false )
1113 SCCOLROW nFirstQueryField = rEntry.nField;
1124 bool bNextColumn =
maCurPos.first == pCol->maCells.end();
1141 nFirstQueryField = rEntry.nField;
1156 if (rItem.
mbMatchEmpty && rEntry.GetQueryItems().size() == 1)
1178 if (bAllStringIgnore && aCell.
hasString())
1182 bool bTestEqualCondition =
false;
1184 (nCol == static_cast<SCCOL>(nFirstQueryField) ? &aCell :
nullptr),
1190 return !aCell.isEmpty();
1204 if (bFirstStringIgnore)
1206 if (aCell.hasString())
1225 bFirstStringIgnore =
false;
1250 for (
SCSIZE j = 0; j < nEntries; j++ )
1259 assert(!
"AdvanceQueryParamEntryField: ++rEntry.nField > MAXCOL");
1277 BoolResetter(
bool& r,
bool b ) : mr(r), mb(r) { r = b; }
1278 ~BoolResetter() { mr = mb; }
1291 bool bFound =
false;
1328 SCCOL nColDiff = nCol - nFoundCol;
1342 for (
SCSIZE j=0; j < nEntries; ++j)
1347 if (rEntry.
nField - nColDiff >= 0)
1348 rEntry.
nField -= nColDiff;
1351 assert(!
"FindEqualOrSortedLastInRange: rEntry.nField -= nColDiff < 0");
1371 for (
SCSIZE j = 0; j < nEntries; j++ )
1376 switch ( rEntry.
eOp )
1413 for (
SCSIZE j = 0; j < nEntries; j++ )
1418 switch ( rEntry.
eOp )
1505 const bool bSingleQueryItem = rEntry.
GetQueryItems().size() == 1;
1560 (nCol == static_cast<SCCOL>(rEntry.
nField) ? &aCell :
nullptr),
1579 for (
SCSIZE j = 0; j < nEntries; j++ )
1588 OSL_FAIL(
"AdvanceQueryParamEntryField: ++rEntry.nField > MAXCOL" );
1607 class NonEmptyCellIndexer
1609 typedef std::map<size_t, sc::CellStoreType::const_iterator> BlockMapType;
1611 BlockMapType maBlockMap;
1622 typedef std::pair<ScRefCellValue, SCROW>
CellType;
1630 NonEmptyCellIndexer(
1632 mrCells(rCells), mnLowIndex(0), mnHighIndex(0), mbValid(true)
1634 if (nEndRow < nStartRow)
1642 sc::CellStoreType::const_position_type aLoPos = mrCells.position(nStartRow);
1646 if (aLoPos.first == rCells.end())
1652 if (bSkipTopStrBlock)
1660 if (aLoPos.first == rCells.end())
1668 SCROW nFirstRow = aLoPos.first->position;
1669 SCROW nLastRow = aLoPos.first->position + aLoPos.first->size - 1;
1671 if (nFirstRow > nEndRow)
1680 if (nFirstRow < nStartRow)
1681 mnLowIndex = nStartRow - nFirstRow;
1689 if (nEndRow < nLastRow)
1691 assert(nEndRow >= nFirstRow);
1692 mnHighIndex = nEndRow - nFirstRow;
1694 maBlockMap.emplace(aLoPos.first->size, aLoPos.first);
1700 sc::CellStoreType::const_position_type aHiPos = mrCells.position(aLoPos.first, nEndRow);
1707 SCROW nBlockEndRow = aHiPos.first->position + aHiPos.first->size - 1;
1708 if (nBlockEndRow < nStartRow)
1719 sc::CellStoreType::const_iterator itBlk = aLoPos.first;
1720 while (itBlk != aHiPos.first)
1728 nPos += itBlk->size;
1729 maBlockMap.emplace(nPos, itBlk);
1735 assert(itBlk != mrCells.end());
1738 assert(itBlk == aHiPos.first);
1739 nPos += itBlk->size;
1740 maBlockMap.emplace(nPos, itBlk);
1743 BlockMapType::const_reverse_iterator ri = maBlockMap.rbegin();
1744 mnHighIndex = ri->first;
1745 mnHighIndex -= ri->second->size;
1746 mnHighIndex += aHiPos.second;
1749 sc::CellStoreType::const_position_type getPosition(
size_t nIndex )
const
1752 assert(mnLowIndex <= nIndex);
1753 assert(nIndex <= mnHighIndex);
1755 sc::CellStoreType::const_position_type aRet(mrCells.end(), 0);
1757 BlockMapType::const_iterator it = maBlockMap.upper_bound(nIndex);
1758 if (it == maBlockMap.end())
1761 sc::CellStoreType::const_iterator itBlk = it->second;
1762 size_t nBlkIndex = it->first - itBlk->size;
1763 assert(nBlkIndex <= nIndex);
1764 assert(nIndex < it->first);
1766 size_t nOffset = nIndex - nBlkIndex;
1768 aRet.second = nOffset;
1772 CellType getCell(
size_t nIndex )
const
1774 std::pair<ScRefCellValue, SCROW> aRet;
1777 sc::CellStoreType::const_position_type aPos = getPosition(nIndex);
1778 if (aPos.first == mrCells.end())
1782 aRet.second = aPos.first->position + aPos.second;
1786 size_t getLowIndex()
const {
return mnLowIndex; }
1788 size_t getHighIndex()
const {
return mnHighIndex; }
1790 bool isValid()
const {
return mbValid; }
1821 if (bFirstStringIgnore)
1823 sc::CellStoreType::const_position_type aPos = pCol->
maCells.position(nRow);
1839 if (!aIndexer.isValid())
1842 size_t nLo = aIndexer.getLowIndex();
1843 size_t nHi = aIndexer.getHighIndex();
1844 NonEmptyCellIndexer::CellType aCellData;
1848 size_t nLastInRange = nLo;
1849 size_t nFirstLastInRange = nLastInRange;
1850 double fLastInRangeValue = bLessEqual ?
1851 -(::std::numeric_limits<double>::max()) :
1852 ::std::numeric_limits<double>::max();
1853 OUString aLastInRangeString;
1855 aLastInRangeString = OUString(
u'\xFFFF');
1857 aCellData = aIndexer.getCell(nLastInRange);
1858 aCell = aCellData.first;
1864 aLastInRangeString = aStr;
1871 fLastInRangeValue = aCell.
mfValue;
1884 bool bFound =
false;
1886 while (nLo <= nHi && !bDone)
1888 size_t nMid = (nLo+nHi)/2;
1891 aCellData = aIndexer.getCell(i);
1892 aCell = aCellData.first;
1898 if (!bStr && !bByString)
1910 if ((nCellVal < rItem.
mfVal) && !::rtl::math::approxEqual(
1911 nCellVal, rItem.
mfVal))
1916 if (fLastInRangeValue < nCellVal)
1918 fLastInRangeValue = nCellVal;
1921 else if (fLastInRangeValue > nCellVal)
1924 nLastInRange = nFirstLastInRange;
1929 else if ((nCellVal > rItem.
mfVal) && !::rtl::math::approxEqual(
1930 nCellVal, rItem.
mfVal))
1935 if (fLastInRangeValue > nCellVal)
1937 fLastInRangeValue = nCellVal;
1940 else if (fLastInRangeValue < nCellVal)
1943 nLastInRange = nFirstLastInRange;
1949 else if (bStr && bByString)
1956 if (nRes < 0 && bLessEqual)
1958 sal_Int32 nTmp = pCollator->
compareString( aLastInRangeString,
1962 aLastInRangeString = aCellStr;
1968 nLastInRange = nFirstLastInRange;
1972 else if (nRes > 0 && !bLessEqual)
1974 sal_Int32 nTmp = pCollator->
compareString( aLastInRangeString,
1978 aLastInRangeString = aCellStr;
1984 nLastInRange = nFirstLastInRange;
1989 else if (!bStr && bByString)
2028 bDone = bFound =
true;
2045 aCellData = aIndexer.getCell(nLo);
2048 nRow = aCellData.second;
2049 maCurPos = aIndexer.getPosition(nLo);
2103 aParam.
maPos = pCol->
maCells.position(nStartRow).first;
2140 debugiter(
"return col %d row %d\n", (
int)rCol, (
int)rRow);
2142 size_t nOffset =
static_cast<size_t>(
mnRow) - r.
maPos->position;
2171 size_t nRow =
static_cast<size_t>(
mnRow);
2173 if (nRow >= r.
maPos->position)
2178 debugiter(
"found valid cell at column %d, row %d\n",
2185 bool bMoreBlocksInColumn =
false;
2192 bMoreBlocksInColumn =
true;
2196 if (!bMoreBlocksInColumn)
2198 debugiter(
"remove column %d at row %d\n",
2209 debugiter(
"advanced column %d to block starting row %d, retrying\n",
2216 debugiter(
"skip empty cells at column %d, row %d\n",
2225 debugiter(
"no more live columns left - done\n");
2241 nNextRow = std::min (nNextRow, static_cast<size_t>(r.maPos->position));
2244 SCROW nRow = std::max(static_cast<SCROW>(nNextRow),
mnRow);
2245 debugiter(
"Next non empty row is %d\n", (
int) nRow);
2266 if (
mnRow > nEndRow)
2276 debugiter(
"moved to valid cell in next row (or end)\n");
2286 if (
mnRow > nEndRow)
2293 nEndTab( rRange.aEnd.
Tab() ),
2294 bCalcAsShown( rDocument.GetDocOptions().IsCalcAsShown() )
2321 nStartRow, nEndCol, nEndRow ) );
2330 bool bFound =
false;
2349 rErr = FormulaError::NONE;
2413 SCCOL nThisHead = 0;
2418 if ( bInitialization ||
pNextEnd[nPos] < nRow )
2424 if (bInitialization)
2426 if ( pArray->
Count() )
2427 pArray->
Search( nStartRow, nIndex );
2436 if ( !nIndex && !pArray->
Count() )
2442 else if ( nIndex < pArray->
Count() )
2458 assert(!
"AttrArray does not range to MAXROW");
2516 if ( nRow > nEndRow )
2527 return ( nRow1 > nRow2 ) || ( nRow1 == nRow2 && nCol1 > nCol2 );
2532 : aCellIter( rDocument, nTable, nCol1, nRow1, nCol2, nRow2 )
2533 , aAttrIter( rDocument, nTable, nCol1, nRow1, nCol2, nRow2 )
2541 , nFoundStartCol( 0 )
2544 , pFoundPattern( nullptr )
2571 bool bUseCell =
false;
2674 mnTab(nTab), maRanges(nMaxRow)
2695 const SCTAB nTab = rTabRanges.mnTab;
2701 for (
bool bFound = aRangeItr.
getFirst(aData); bFound; bFound = aRangeItr.
getNext(aData))
2714 for (
const auto& rTabRanges : *mpTabRangesArray)
2716 const SCTAB nTab = rTabRanges.mnTab;
2723 for (
bool bFound = aRangeItr.
getFirst(aData); bFound; bFound = aRangeItr.
getNext(aData))
2729 aCxt, aData.mnRow1, aData.mnRow2, &aProgress, nProgressStart);
2731 nProgressStart +=
mrDoc.
maTabs[nTab]->GetWeightedCount(aData.mnRow1, aData.mnRow2);
2738 sal_uInt32 nCellCount = 0;
2744 nCellCount +=
mrDoc.
maTabs[nTab]->GetWeightedCount();
2758 nProgressStart +=
mrDoc.
maTabs[nTab]->GetWeightedCount();
2770 nIterStartCol( nCol1 ),
2771 nIterEndCol( nCol1 )
Matrix data type that can store values of mixed types.
ScValueIterator(ScDocument &rDocument, const ScRange &rRange, SubtotalFlags nSubTotalFlags=SubtotalFlags::NONE, bool bTextAsZero=false)
bool getFirst(RangeData &rRange)
bool bIgnoreMismatchOnLeadingStrings
ScUsedAreaIterator(ScDocument &rDocument, SCTAB nTable, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
sal_uInt8 nStopOnMismatch
static void ScAttrArray_IterGetNumberFormat(sal_uInt32 &nFormat, const ScAttrArray *&rpArr, SCROW &nAttrEndRow, const ScAttrArray *pNewArr, SCROW nRow, const ScDocument &rDoc, const ScInterpreterContext *pContext=nullptr)
const size_t count(pCandidateA->getBorderLines().size())
sal_uInt8 nTestEqualCondition
OUString getString() const
OUString getString() const
bool isValidQuery(SCROW mnRow, const ScMatrix &rMat) const
~ScHorizontalAttrIterator()
std::unique_ptr< ScAttrArray > pAttrArray
ScRefCellValue * GetNext(SCCOL &rCol, SCROW &rRow)
sal_Int32 compareString(const OUString &s1, const OUString &s2) const
ScDocument & GetDoc() const
~ScHorizontalValueIterator()
ScDocRowHeightUpdater(ScDocument &rDoc, OutputDevice *pOutDev, double fPPTX, double fPPTY, const ::std::vector< TabRanges > *pTabRangesArray)
Passing a NULL pointer to pTabRangesArray forces the heights of all rows in all tables to be updated...
void IncTab(SCTAB nDelta=1)
std::unique_ptr< const ScPatternAttr *[]> ppPatterns
OUString getString(const ScDocument *pDoc) const
Retrieve string value.
DataAccessMatrix(ScDBQueryParamMatrix *pParam)
ScTable * FetchTable(SCTAB nTab)
rtl_uString * getDataIgnoreCase()
ScColumn * FetchColumn(SCCOL nCol)
virtual bool getFirst(Value &rValue) override
const ScInterpreterContext & mrContext
bool GetPos(SCCOL &rCol, SCROW &rRow)
bool equalsWithoutFormat(const ScAddress &rPos) const
::std::set< SCROW >::const_iterator maEnd
QueryItemsType & GetQueryItems()
std::unique_ptr< ScAttrIterator > pColIter
static SC_DLLPUBLIC CollatorWrapper * GetCollator()
const ScAttrArray * pAttrArray
bool GetNext(Value &rValue)
Does NOT reset rValue if no value found!
void AdvanceQueryParamEntryField()
This is very similar to ScCellValue, except that it references the original value instead of copying ...
static bool IsQueryValid(ScDocument &rDoc, const ScQueryParam &rParam, SCTAB nTab, SCROW nRow, const ScRefCellValue *pCell)
SubtotalFlags mnSubTotalFlags
mdds::multi_type_vector< CellFunc, CellStoreEvent > CellStoreType
ScQueryCellIterator(ScDocument &rDocument, const ScInterpreterContext &rContext, SCTAB nTable, const ScQueryParam &aParam, bool bMod)
static const sc::CellStoreType * GetColumnCellStore(ScDocument &rDoc, SCTAB nTab, SCCOL nCol)
bool getNext(RangeData &rRange)
DataAccessInternal(ScDBQueryParamInternal *pParam, ScDocument &rDoc, const ScInterpreterContext &rContext)
std::unique_ptr< SCSIZE[]> pIndices
const Item & GetQueryItem() const
double GetDouble(SCSIZE nC, SCSIZE nR) const
::std::set< SCROW >::const_iterator maItr
const ScPatternAttr * pPattern
bool equalsWithoutFormat(const ScRefCellValue &r) const
Store arbitrary cell value of any kind.
const ScColumn * getColumn() const
const sc::CellStoreType * mpCells
const mdds::mtv::element_t element_type_formula
bool IsEqualConditionFulfilled() const
void SetTab(SCTAB nTab)
Set a(nother) sheet and (re)init.
const EditTextObject * mpEditText
void SetStopOnMismatch(bool bVal)
If set, iterator stops on first non-matching cell content.
enumrange< T >::Iterator begin(enumrange< T >)
ScFormulaCell * mpFormula
SC_DLLPUBLIC SCROW MaxRow() const
size_t SCSIZE
size_t typedef to be able to find places where code was changed from USHORT to size_t and is used to ...
sal_Int32 SCCOLROW
a type capable of holding either SCCOL or SCROW
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
SC_DLLPUBLIC SCTAB GetTableCount() const
virtual ~DataAccessInternal() override
SC_DLLPUBLIC SCSIZE GetEntryCount() const
sc::CellStoreType maCells
SC_DLLPUBLIC const ScQueryEntry & GetEntry(SCSIZE n) const
void InitPos()
Initialize position for new column.
ScFormulaCell * mpFormula
bool IsStringOrEmpty(SCSIZE nIndex) const
const ::std::vector< TabRanges > * mpTabRangesArray
sal_uInt32 GetNumberFormat(const ScInterpreterContext &rContext, SCROW nRow) const
bool Search(SCROW nRow, SCSIZE &nIndex) const
~ScHorizontalCellIterator()
ScAttrRectIterator(ScDocument &rDocument, SCTAB nTable, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
void SetTestEqualCondition(bool bVal)
If set, an additional test for SC_EQUAL condition is executed in ScTable::ValidQuery() if SC_LESS_EQU...
ScCountIfCellIterator(ScDocument &rDocument, const ScInterpreterContext &rContext, SCTAB nTable, const ScQueryParam &aParam)
SC_DLLPUBLIC SCCOL GetAllocatedColumnsCount(SCTAB nTab) const
bool GetNext(double &rValue, FormulaError &rErr)
Does NOT reset rValue if no value found!
void PutInOrder(T &nStart, T &nEnd)
ScDBQueryParamMatrix * mpParam
constexpr OUStringLiteral aData
std::vector< ScAttrEntry > mvData
std::vector< ColParam >::iterator maColPos
SvNumFormatType nNumFmtType
sc::CellStoreType::const_iterator maEnd
SC_DLLPUBLIC SCCOL MaxCol() const
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
void AdvanceQueryParamEntryField()
std::unique_ptr< SCCOL[]> pHorizEnd
svl::SharedString GetString(SCSIZE nC, SCSIZE nR) const
bool RowFiltered(SCROW nRow, SCTAB nTab, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
void IncCol(SCCOL nDelta=1)
const svl::SharedString * mpString
bool ValidCol(SCCOL nCol) const
virtual bool getFirst(Value &rValue) override
svl::SharedString * mpString
bool GetThis(double &rValue, FormulaError &rErr)
See if the cell at the current position is a non-empty cell.
SvNumberFormatter * GetFormatTable() const
std::vector< ColParam > maColPositions
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
const mdds::mtv::element_t element_type_empty
void IncRow(SCROW nDelta=1)
OUString ScResId(const char *pId)
VclPtr< OutputDevice > mpOutDev
bool StoppedOnMismatch() const
const mdds::mtv::element_t element_type_numeric
Mapped standard element types (for convenience).
sal_uInt32 GetNumberFormat(SvNumberFormatter *) const
SCROW FindNextNonEmptyRow()
Find the next row that has some real content in one of its columns.
bool GetFirst(Value &rValue)
Does NOT reset rValue if no value found!
TabRanges(SCTAB nTab, SCROW nMaxRow)
sc::CellStoreType::const_position_type PositionType
static CollatorWrapper * GetCaseCollator()
ScHorizontalAttrIterator(ScDocument &rDocument, SCTAB nTable, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
std::unique_ptr< ScAttrIterator > pColIter
ScCellIterator(ScDocument &rDoc, const ScRange &rRange, SubtotalFlags nSubTotalFlags=SubtotalFlags::NONE)
bool FindEqualOrSortedLastInRange(SCCOL &nFoundCol, SCROW &nFoundRow)
In a range assumed to be sorted find either the last of a sequence of equal entries or the last being...
::std::set< SCROW > & mrBreaks
bool mbRangeLookup
for spreadsheet functions like MATCH, LOOKUP, HLOOKUP, VLOOKUP
svl::SharedString maString
enumrange< T >::Iterator end(enumrange< T >)
const NodeContext & mrContext
ScHorizontalCellIterator(ScDocument &rDocument, SCTAB nTable, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
SC_DLLPUBLIC double RoundValueAsShown(double fVal, sal_uInt32 nFormat, const ScInterpreterContext *pContext=nullptr) const
std::unique_ptr< ScHorizontalCellIterator > pCellIter
static constexpr SCROW NOT_FOUND
::std::unique_ptr< ScDBQueryParamBase > mpParam
bool ValidRow(SCROW nRow) const
sc::CellStoreType::const_iterator maPos
static const ScAttrArray * GetAttrArrayByCol(ScDocument &rDoc, SCTAB nTab, SCCOL nCol)
bool IsEmpty(SCSIZE nC, SCSIZE nR) const
bool GetFirst(double &rValue, FormulaError &rErr)
Does NOT reset rValue if no value found!
void InitForNextRow(bool bInitialization)
const mdds::mtv::element_t element_type_edittext
void InitPos()
Initialize position for new column.
ScHorizontalValueIterator(ScDocument &rDocument, const ScRange &rRange)
virtual bool getNext(Value &rValue) override
const ScInterpreterContext & mrContext
const ScPatternAttr * GetNext(SCCOL &rCol1, SCCOL &rCol2, SCROW &rRow1, SCROW &rRow2)
SvNumFormatType GetNumberFormatType(sal_uInt32 nFIndex) const
const ScPatternAttr * GetNext(SCCOL &rCol, SCROW &rRow1, SCROW &rRow2)
std::vector< sc::FormulaGroupEntry > GetFormulaGroupEntries()
Get all non-grouped formula cells and formula cell groups in the whole column.
SC_DLLPUBLIC ScPatternAttr * GetDefPattern() const
ScHorizontalAttrIterator aAttrIter
EditTextObject * mpEditText
void GetCurNumFmtInfo(const ScInterpreterContext &rContext, SvNumFormatType &nType, sal_uInt32 &nIndex)
bool GetNext(double &rValue, FormulaError &rErr)
Does NOT reset rValue if no value found!
ScCellValue getCellValue() const
SC_DLLPUBLIC bool RowHidden(SCROW nRow, SCTAB nTab, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
ScRefCellValue toRefCell(const sc::CellStoreType::const_iterator &itPos, size_t nOffset)
std::vector< Item > QueryItemsType
virtual bool getCurrent(Value &rValue) override
virtual ~DataAccessMatrix() override
const ScPatternAttr * GetNext(SCCOL &rCol1, SCCOL &rCol2, SCROW &rRow)
const ScPatternAttr * GetPatternRange(SCROW &rStartRow, SCROW &rEndRow, SCROW nRow) const
Returns if you search for attributes at nRow the range from rStartRow to rEndRow where that attribute...
SfxObjectShell * GetDocumentShell() const
ScDocAttrIterator(ScDocument &rDocument, SCTAB nTable, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
virtual bool getCurrent(Value &rValue) override
SubtotalFlags mnSubTotalFlags
const ScPatternAttr * pFoundPattern
ScInterpreterContext * pContext
ScRowBreakIterator(::std::set< SCROW > &rBreaks)
std::unique_ptr< EditTextObject > Clone() const
ScHorizontalCellIterator aCellIter
SCCOL GetAllocatedColumnsCount() const
const mdds::mtv::element_t element_type_string
::std::unique_ptr< DataAccess > mpData
virtual bool getNext(Value &rValue) override
ScDBQueryDataIterator(ScDocument &rDocument, const ScInterpreterContext &rContext, std::unique_ptr< ScDBQueryParamBase > pParam)
bool ValidTab(SCTAB nTab)
std::unique_ptr< SCROW[]> pNextEnd
Each instance of this struct represents a single filtering criteria.
ScDBQueryParamInternal * mpParam
utl::SearchParam::SearchType eSearchType
const ScAttrArray * pAttrArray
bool IsValueOrEmpty(SCSIZE nC, SCSIZE nR) const
ScRefCellValue maFoundCell
static bool IsGreater(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
bool IsDefaultItem(const SfxPoolItem *pItem)