LCOV - code coverage report
Current view: top level - sc/source/core/data - dpcache.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 418 561 74.5 %
Date: 2014-11-03 Functions: 66 68 97.1 %
Legend: Lines: hit not hit

          Line data    Source code
       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             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "dpcache.hxx"
      21             : 
      22             : #include "document.hxx"
      23             : #include "queryentry.hxx"
      24             : #include "queryparam.hxx"
      25             : #include "dpglobal.hxx"
      26             : #include "dpobject.hxx"
      27             : #include "globstr.hrc"
      28             : #include "docoptio.hxx"
      29             : #include "dpitemdata.hxx"
      30             : #include "dputil.hxx"
      31             : #include "dpnumgroupinfo.hxx"
      32             : 
      33             : #include <rtl/math.hxx>
      34             : #include <unotools/textsearch.hxx>
      35             : #include <unotools/localedatawrapper.hxx>
      36             : #include <svl/zforlist.hxx>
      37             : 
      38             : #if DEBUG_PIVOT_TABLE
      39             : #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
      40             : #endif
      41             : 
      42             : using namespace ::com::sun::star;
      43             : 
      44             : using ::com::sun::star::uno::Exception;
      45             : using ::com::sun::star::uno::Reference;
      46             : using ::com::sun::star::uno::UNO_QUERY;
      47             : using ::com::sun::star::uno::UNO_QUERY_THROW;
      48             : 
      49          24 : ScDPCache::GroupItems::GroupItems() : mnGroupType(0) {}
      50             : 
      51          12 : ScDPCache::GroupItems::GroupItems(const ScDPNumGroupInfo& rInfo, sal_Int32 nGroupType) :
      52          12 :     maInfo(rInfo), mnGroupType(nGroupType) {}
      53             : 
      54         410 : ScDPCache::Field::Field() : mnNumFormat(0) {}
      55             : 
      56         140 : ScDPCache::ScDPCache(ScDocument* pDoc) :
      57             :     mpDoc( pDoc ),
      58             :     mnColumnCount ( 0 ),
      59             :     maEmptyRows(0, MAXROW, true),
      60             :     mnDataSize(-1),
      61             :     mnRowCount(0),
      62         140 :     mbDisposing(false)
      63             : {
      64         140 : }
      65             : 
      66             : namespace {
      67             : 
      68             : struct ClearObjectSource : std::unary_function<ScDPObject*, void>
      69             : {
      70          30 :     void operator() (ScDPObject* p) const
      71             :     {
      72          30 :         p->ClearTableData();
      73          30 :     }
      74             : };
      75             : 
      76             : }
      77             : 
      78         280 : ScDPCache::~ScDPCache()
      79             : {
      80             :     // Make sure no live ScDPObject instances hold reference to this cache any
      81             :     // more.
      82         140 :     mbDisposing = true;
      83         140 :     std::for_each(maRefObjects.begin(), maRefObjects.end(), ClearObjectSource());
      84         140 : }
      85             : 
      86             : namespace {
      87             : 
      88             : /**
      89             :  * While the macro interpret level is incremented, the formula cells are
      90             :  * (semi-)guaranteed to be interpreted.
      91             :  */
      92             : class MacroInterpretIncrementer
      93             : {
      94             : public:
      95         146 :     MacroInterpretIncrementer(ScDocument* pDoc) :
      96         146 :         mpDoc(pDoc)
      97             :     {
      98         146 :         mpDoc->IncMacroInterpretLevel();
      99         146 :     }
     100         146 :     ~MacroInterpretIncrementer()
     101             :     {
     102         146 :         mpDoc->DecMacroInterpretLevel();
     103         146 :     }
     104             : private:
     105             :     ScDocument* mpDoc;
     106             : };
     107             : 
     108         410 : OUString createLabelString(ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab)
     109             : {
     110         410 :     OUString aDocStr = pDoc->GetString(nCol, nRow, nTab);
     111         410 :     if (aDocStr.isEmpty())
     112             :     {
     113             :         // Replace an empty label string with column name.
     114          28 :         OUStringBuffer aBuf;
     115          28 :         aBuf.append(ScGlobal::GetRscString(STR_COLUMN));
     116          28 :         aBuf.append(' ');
     117             : 
     118          28 :         ScAddress aColAddr(nCol, 0, 0);
     119          28 :         aBuf.append(aColAddr.Format(SCA_VALID_COL, NULL));
     120          28 :         aDocStr = aBuf.makeStringAndClear();
     121             :     }
     122         410 :     return aDocStr;
     123             : }
     124             : 
     125        4686 : void initFromCell(
     126             :     ScDPCache& rCache, ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab,
     127             :     ScDPItemData& rData, sal_uLong& rNumFormat)
     128             : {
     129        4686 :     OUString aDocStr = pDoc->GetString(nCol, nRow, nTab);
     130        4686 :     rNumFormat = 0;
     131             : 
     132        4686 :     ScAddress aPos(nCol, nRow, nTab);
     133             : 
     134        4686 :     if (pDoc->GetErrCode(aPos))
     135             :     {
     136           0 :         rData.SetErrorString(rCache.InternString(aDocStr));
     137             :     }
     138        4686 :     else if (pDoc->HasValueData(nCol, nRow, nTab))
     139             :     {
     140        2884 :         double fVal = pDoc->GetValue(aPos);
     141        2884 :         rNumFormat = pDoc->GetNumberFormat(aPos);
     142        2884 :         rData.SetValue(fVal);
     143             :     }
     144        1802 :     else if (pDoc->HasData(nCol, nRow, nTab))
     145             :     {
     146        1738 :         rData.SetString(rCache.InternString(aDocStr));
     147             :     }
     148             :     else
     149          64 :         rData.SetEmpty();
     150        4686 : }
     151             : 
     152      104612 : struct Bucket
     153             : {
     154             :     ScDPItemData maValue;
     155             :     SCROW mnOrderIndex;
     156             :     SCROW mnDataIndex;
     157             :     SCROW mnValueSortIndex;
     158        4686 :     Bucket(const ScDPItemData& rValue, SCROW nOrder, SCROW nData) :
     159        4686 :         maValue(rValue), mnOrderIndex(nOrder), mnDataIndex(nData), mnValueSortIndex(0) {}
     160             : };
     161             : 
     162             : #if DEBUG_PIVOT_TABLE
     163             : #include <iostream>
     164             : using std::cout;
     165             : using std::endl;
     166             : 
     167             : struct PrintBucket : std::unary_function<Bucket, void>
     168             : {
     169             :     void operator() (const Bucket& v) const
     170             :     {
     171             :         cout << "value: " << v.maValue.GetValue() << "  order index: " << v.mnOrderIndex << "  data index: " << v.mnDataIndex << "  value sort index: " << v.mnValueSortIndex << endl;
     172             :     }
     173             : };
     174             : 
     175             : #endif
     176             : 
     177             : struct LessByValue : std::binary_function<Bucket, Bucket, bool>
     178             : {
     179       19830 :     bool operator() (const Bucket& left, const Bucket& right) const
     180             :     {
     181       19830 :         return left.maValue < right.maValue;
     182             :     }
     183             : };
     184             : 
     185             : struct LessByValueSortIndex : std::binary_function<Bucket, Bucket, bool>
     186             : {
     187       26738 :     bool operator() (const Bucket& left, const Bucket& right) const
     188             :     {
     189       26738 :         return left.mnValueSortIndex < right.mnValueSortIndex;
     190             :     }
     191             : };
     192             : 
     193             : struct LessByDataIndex : std::binary_function<Bucket, Bucket, bool>
     194             : {
     195       25972 :     bool operator() (const Bucket& left, const Bucket& right) const
     196             :     {
     197       25972 :         return left.mnDataIndex < right.mnDataIndex;
     198             :     }
     199             : };
     200             : 
     201             : struct EqualByOrderIndex : std::binary_function<Bucket, Bucket, bool>
     202             : {
     203        4276 :     bool operator() (const Bucket& left, const Bucket& right) const
     204             :     {
     205        4276 :         return left.mnOrderIndex == right.mnOrderIndex;
     206             :     }
     207             : };
     208             : 
     209             : class PushBackValue : std::unary_function<Bucket, void>
     210             : {
     211             :     ScDPCache::ItemsType& mrItems;
     212             : public:
     213         410 :     PushBackValue(ScDPCache::ItemsType& _items) : mrItems(_items) {}
     214        2006 :     void operator() (const Bucket& v)
     215             :     {
     216        2006 :         mrItems.push_back(v.maValue);
     217        2006 :     }
     218             : };
     219             : 
     220             : class PushBackOrderIndex : std::unary_function<Bucket, void>
     221             : {
     222             :     ScDPCache::IndexArrayType& mrData;
     223             : public:
     224         410 :     PushBackOrderIndex(ScDPCache::IndexArrayType& _items) : mrData(_items) {}
     225        4686 :     void operator() (const Bucket& v)
     226             :     {
     227        4686 :         mrData.push_back(v.mnOrderIndex);
     228        4686 :     }
     229             : };
     230             : 
     231             : class TagValueSortOrder : std::unary_function<Bucket, void>
     232             : {
     233             :     SCROW mnCurIndex;
     234             : public:
     235         410 :     TagValueSortOrder() : mnCurIndex(0) {}
     236        4686 :     void operator() (Bucket& v)
     237             :     {
     238        4686 :         v.mnValueSortIndex = mnCurIndex++;
     239        4686 :     }
     240             : };
     241             : 
     242         410 : void processBuckets(std::vector<Bucket>& aBuckets, ScDPCache::Field& rField)
     243             : {
     244         410 :     if (aBuckets.empty())
     245         410 :         return;
     246             : 
     247             :     // Sort by the value.
     248         410 :     std::sort(aBuckets.begin(), aBuckets.end(), LessByValue());
     249             : 
     250             :     // Remember this sort order.
     251         410 :     std::for_each(aBuckets.begin(), aBuckets.end(), TagValueSortOrder());
     252             : 
     253             :     {
     254             :         // Set order index such that unique values have identical index value.
     255         410 :         SCROW nCurIndex = 0;
     256         410 :         std::vector<Bucket>::iterator it = aBuckets.begin(), itEnd = aBuckets.end();
     257         410 :         ScDPItemData aPrev = it->maValue;
     258         410 :         it->mnOrderIndex = nCurIndex;
     259        4686 :         for (++it; it != itEnd; ++it)
     260             :         {
     261        4276 :             if (!aPrev.IsCaseInsEqual(it->maValue))
     262        1596 :                 ++nCurIndex;
     263             : 
     264        4276 :             it->mnOrderIndex = nCurIndex;
     265        4276 :             aPrev = it->maValue;
     266         410 :         }
     267             :     }
     268             : 
     269             :     // Re-sort the bucket this time by the data index.
     270         410 :     std::sort(aBuckets.begin(), aBuckets.end(), LessByDataIndex());
     271             : 
     272             :     // Copy the order index series into the field object.
     273         410 :     rField.maData.reserve(aBuckets.size());
     274         410 :     std::for_each(aBuckets.begin(), aBuckets.end(), PushBackOrderIndex(rField.maData));
     275             : 
     276             :     // Sort by the value again.
     277         410 :     std::sort(aBuckets.begin(), aBuckets.end(), LessByValueSortIndex());
     278             : 
     279             :     // Unique by value.
     280             :     std::vector<Bucket>::iterator itUniqueEnd =
     281         410 :         std::unique(aBuckets.begin(), aBuckets.end(), EqualByOrderIndex());
     282             : 
     283             :     // Copy the unique values into items.
     284         410 :     std::vector<Bucket>::iterator itBeg = aBuckets.begin();
     285         410 :     size_t nLen = distance(itBeg, itUniqueEnd);
     286         410 :     rField.maItems.reserve(nLen);
     287         410 :     std::for_each(itBeg, itUniqueEnd, PushBackValue(rField.maItems));
     288             : }
     289             : 
     290             : }
     291             : 
     292         146 : bool ScDPCache::InitFromDoc(ScDocument* pDoc, const ScRange& rRange)
     293             : {
     294         146 :     Clear();
     295             : 
     296             :     // Make sure the formula cells within the data range are interpreted
     297             :     // during this call, for this method may be called from the interpretation
     298             :     // of GETPIVOTDATA, which disables nested formula interpretation without
     299             :     // increasing the macro level.
     300         146 :     MacroInterpretIncrementer aMacroInc(pDoc);
     301             : 
     302         146 :     SCROW nStartRow = rRange.aStart.Row();  // start of data
     303         146 :     SCROW nEndRow = rRange.aEnd.Row();
     304             : 
     305             :     // Sanity check
     306         146 :     if (!ValidRow(nStartRow) || !ValidRow(nEndRow) || nEndRow <= nStartRow)
     307          42 :         return false;
     308             : 
     309         104 :     sal_uInt16 nStartCol = rRange.aStart.Col();
     310         104 :     sal_uInt16 nEndCol = rRange.aEnd.Col();
     311         104 :     sal_uInt16 nDocTab = rRange.aStart.Tab();
     312             : 
     313         104 :     mnColumnCount = nEndCol - nStartCol + 1;
     314             : 
     315             :     // this row count must include the trailing empty rows.
     316         104 :     mnRowCount = nEndRow - nStartRow; // skip the topmost label row.
     317             : 
     318             :     // Skip trailing empty rows if exists.
     319         104 :     SCCOL nCol1 = nStartCol, nCol2 = nEndCol;
     320         104 :     SCROW nRow1 = nStartRow, nRow2 = nEndRow;
     321         104 :     pDoc->ShrinkToDataArea(nDocTab, nCol1, nRow1, nCol2, nRow2);
     322         104 :     bool bTailEmptyRows = nEndRow > nRow2; // Trailing empty rows exist.
     323         104 :     nEndRow = nRow2;
     324             : 
     325         104 :     if (nEndRow <= nStartRow)
     326             :     {
     327             :         // Check this again since the end row position has changed. It's
     328             :         // possible that the new end row becomes lower than the start row
     329             :         // after the shrinkage.
     330           0 :         Clear();
     331           0 :         return false;
     332             :     }
     333             : 
     334         104 :     maFields.reserve(mnColumnCount);
     335         514 :     for (size_t i = 0; i < static_cast<size_t>(mnColumnCount); ++i)
     336         410 :         maFields.push_back(new Field);
     337             : 
     338         104 :     maLabelNames.reserve(mnColumnCount+1);
     339             : 
     340         208 :     ScDPItemData aData;
     341         514 :     for (sal_uInt16 nCol = nStartCol; nCol <= nEndCol; ++nCol)
     342             :     {
     343         410 :         AddLabel(createLabelString(pDoc, nCol, nStartRow, nDocTab));
     344         410 :         Field& rField = maFields[nCol-nStartCol];
     345         410 :         std::vector<Bucket> aBuckets;
     346         410 :         aBuckets.reserve(nEndRow-nStartRow); // skip the topmost label cell.
     347             : 
     348             :         // Push back all original values.
     349         410 :         SCROW nOffset = nStartRow + 1;
     350        5096 :         for (SCROW i = 0, n = nEndRow-nStartRow; i < n; ++i)
     351             :         {
     352        4686 :             SCROW nRow = i + nOffset;
     353        4686 :             sal_uLong nNumFormat = 0;
     354        4686 :             initFromCell(*this, pDoc, nCol, nRow, nDocTab, aData, nNumFormat);
     355        4686 :             aBuckets.push_back(Bucket(aData, 0, i));
     356             : 
     357        4686 :             if (!aData.IsEmpty())
     358             :             {
     359        4622 :                 maEmptyRows.insert_back(i, i+1, false);
     360        4622 :                 if (nNumFormat)
     361             :                     // Only take non-default number format.
     362        1630 :                     rField.mnNumFormat = nNumFormat;
     363             :             }
     364             :         }
     365             : 
     366         410 :         processBuckets(aBuckets, rField);
     367             : 
     368         410 :         if (bTailEmptyRows)
     369             :         {
     370             :             // If the last item is not empty, append one. Note that the items
     371             :             // are sorted, and empty item should come last when sorted.
     372          56 :             if (rField.maItems.empty() || !rField.maItems.back().IsEmpty())
     373             :             {
     374          48 :                 aData.SetEmpty();
     375          48 :                 rField.maItems.push_back(aData);
     376             :             }
     377             :         }
     378         410 :     }
     379             : 
     380         104 :     PostInit();
     381         250 :     return true;
     382             : }
     383             : 
     384           0 : bool ScDPCache::InitFromDataBase(DBConnector& rDB)
     385             : {
     386           0 :     Clear();
     387             : 
     388             :     try
     389             :     {
     390           0 :         mnColumnCount = rDB.getColumnCount();
     391           0 :         maFields.clear();
     392           0 :         maFields.reserve(mnColumnCount);
     393           0 :         for (size_t i = 0; i < static_cast<size_t>(mnColumnCount); ++i)
     394           0 :             maFields.push_back(new Field);
     395             : 
     396             :         // Get column titles and types.
     397           0 :         maLabelNames.clear();
     398           0 :         maLabelNames.reserve(mnColumnCount+1);
     399             : 
     400           0 :         for (sal_Int32 nCol = 0; nCol < mnColumnCount; ++nCol)
     401             :         {
     402           0 :             OUString aColTitle = rDB.getColumnLabel(nCol);
     403           0 :             AddLabel(aColTitle);
     404           0 :         }
     405             : 
     406           0 :         std::vector<Bucket> aBuckets;
     407           0 :         ScDPItemData aData;
     408           0 :         for (sal_Int32 nCol = 0; nCol < mnColumnCount; ++nCol)
     409             :         {
     410           0 :             if (!rDB.first())
     411           0 :                 continue;
     412             : 
     413           0 :             aBuckets.clear();
     414           0 :             Field& rField = maFields[nCol];
     415           0 :             SCROW nRow = 0;
     416           0 :             do
     417             :             {
     418           0 :                 short nFormatType = NUMBERFORMAT_UNDEFINED;
     419           0 :                 aData.SetEmpty();
     420           0 :                 rDB.getValue(nCol, aData, nFormatType);
     421           0 :                 aBuckets.push_back(Bucket(aData, 0, nRow));
     422           0 :                 if (!aData.IsEmpty())
     423             :                 {
     424           0 :                     maEmptyRows.insert_back(nRow, nRow+1, false);
     425           0 :                     SvNumberFormatter* pFormatter = mpDoc->GetFormatTable();
     426           0 :                     rField.mnNumFormat = pFormatter ? pFormatter->GetStandardFormat(nFormatType) : 0;
     427             :                 }
     428             : 
     429           0 :                 ++nRow;
     430             :             }
     431           0 :             while (rDB.next());
     432             : 
     433           0 :             processBuckets(aBuckets, rField);
     434             :         }
     435             : 
     436           0 :         rDB.finish();
     437             : 
     438           0 :         if (!maFields.empty())
     439           0 :             mnRowCount = maFields[0].maData.size();
     440             : 
     441           0 :         PostInit();
     442           0 :         return true;
     443             :     }
     444           0 :     catch (const Exception&)
     445             :     {
     446           0 :         return false;
     447             :     }
     448             : }
     449             : 
     450        2244 : bool ScDPCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam) const
     451             : {
     452        2244 :     if (!rParam.GetEntryCount())
     453           0 :         return true;
     454             : 
     455        2244 :     if (!rParam.GetEntry(0).bDoQuery)
     456        2022 :         return true;
     457             : 
     458         222 :     bool bMatchWholeCell = mpDoc->GetDocOptions().IsMatchWholeCell();
     459             : 
     460         222 :     SCSIZE nEntryCount = rParam.GetEntryCount();
     461         222 :     std::vector<bool> aPassed(nEntryCount, false);
     462             : 
     463         222 :     long nPos = -1;
     464             :     CollatorWrapper* pCollator = (rParam.bCaseSens ? ScGlobal::GetCaseCollator() :
     465         222 :                                   ScGlobal::GetCollator() );
     466             :     ::utl::TransliterationWrapper* pTransliteration = (rParam.bCaseSens ?
     467         222 :                                                        ScGlobal::GetCaseTransliteration() : ScGlobal::GetpTransliteration());
     468             : 
     469         634 :     for (size_t i = 0; i < nEntryCount && rParam.GetEntry(i).bDoQuery; ++i)
     470             :     {
     471         412 :         const ScQueryEntry& rEntry = rParam.GetEntry(i);
     472         412 :         const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
     473             :         // we can only handle one single direct query
     474             :         // #i115431# nField in QueryParam is the sheet column, not the field within the source range
     475         412 :         SCCOL nQueryCol = (SCCOL)rEntry.nField;
     476         412 :         if ( nQueryCol < rParam.nCol1 )
     477           0 :             nQueryCol = rParam.nCol1;
     478         412 :         if ( nQueryCol > rParam.nCol2 )
     479           0 :             nQueryCol = rParam.nCol2;
     480         412 :         SCCOL nSourceField = nQueryCol - rParam.nCol1;
     481         412 :         SCROW nId = GetItemDataId( nSourceField, nRow, false );
     482         412 :         const ScDPItemData* pCellData = GetItemDataById( nSourceField, nId );
     483             : 
     484         412 :         bool bOk = false;
     485             : 
     486         412 :         if (rEntry.GetQueryItem().meType == ScQueryEntry::ByEmpty)
     487             :         {
     488           0 :             if (rEntry.IsQueryByEmpty())
     489           0 :                 bOk = pCellData->IsEmpty();
     490             :             else
     491             :             {
     492             :                 OSL_ASSERT(rEntry.IsQueryByNonEmpty());
     493           0 :                 bOk = !pCellData->IsEmpty();
     494             :             }
     495             :         }
     496         412 :         else if (rEntry.GetQueryItem().meType != ScQueryEntry::ByString && pCellData->IsValue())
     497             :         {   // by Value
     498         412 :             double nCellVal = pCellData->GetValue();
     499             : 
     500         412 :             switch (rEntry.eOp)
     501             :             {
     502             :                 case SC_EQUAL :
     503          32 :                     bOk = ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     504          32 :                     break;
     505             :                 case SC_LESS :
     506           0 :                     bOk = (nCellVal < rItem.mfVal) && !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     507           0 :                     break;
     508             :                 case SC_GREATER :
     509         190 :                     bOk = (nCellVal > rItem.mfVal) && !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     510         190 :                     break;
     511             :                 case SC_LESS_EQUAL :
     512         190 :                     bOk = (nCellVal < rItem.mfVal) || ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     513         190 :                     break;
     514             :                 case SC_GREATER_EQUAL :
     515           0 :                     bOk = (nCellVal > rItem.mfVal) || ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     516           0 :                     break;
     517             :                 case SC_NOT_EQUAL :
     518           0 :                     bOk = !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
     519           0 :                     break;
     520             :                 default:
     521           0 :                     bOk= false;
     522           0 :                     break;
     523             :             }
     524             :         }
     525           0 :         else if ((rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL)
     526           0 :                  || (rEntry.GetQueryItem().meType == ScQueryEntry::ByString
     527           0 :                      && pCellData->HasStringData() )
     528             :                 )
     529             :         {   // by String
     530           0 :             OUString  aCellStr = pCellData->GetString();
     531             : 
     532           0 :             bool bRealRegExp = (rParam.bRegExp && ((rEntry.eOp == SC_EQUAL)
     533           0 :                                                    || (rEntry.eOp == SC_NOT_EQUAL)));
     534           0 :             bool bTestRegExp = false;
     535           0 :             if (bRealRegExp || bTestRegExp)
     536             :             {
     537           0 :                 sal_Int32 nStart = 0;
     538           0 :                 sal_Int32 nEnd   = aCellStr.getLength();
     539             : 
     540             :                 bool bMatch = (bool) rEntry.GetSearchTextPtr( rParam.bCaseSens )
     541           0 :                               ->SearchForward( aCellStr, &nStart, &nEnd );
     542             :                 // from 614 on, nEnd is behind the found text
     543           0 :                 if (bMatch && bMatchWholeCell
     544           0 :                     && (nStart != 0 || nEnd != aCellStr.getLength()))
     545           0 :                     bMatch = false;    // RegExp must match entire cell string
     546           0 :                 if (bRealRegExp)
     547           0 :                     bOk = ((rEntry.eOp == SC_NOT_EQUAL) ? !bMatch : bMatch);
     548             :             }
     549           0 :             if (!bRealRegExp)
     550             :             {
     551           0 :                 if (rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL)
     552             :                 {
     553           0 :                     if (bMatchWholeCell)
     554             :                     {
     555             :                         // TODO: Use shared string for fast equality check.
     556           0 :                         OUString aStr = rEntry.GetQueryItem().maString.getString();
     557           0 :                         bOk = pTransliteration->isEqual(aCellStr, aStr);
     558           0 :                         bool bHasStar = false;
     559             :                         sal_Int32 nIndex;
     560           0 :                         if (( nIndex = aStr.indexOf('*') ) != -1)
     561           0 :                             bHasStar = true;
     562           0 :                         if (bHasStar && (nIndex>0))
     563             :                         {
     564           0 :                             for (sal_Int32 j=0;(j<nIndex) && (j< aCellStr.getLength()) ; j++)
     565             :                             {
     566           0 :                                 if (aCellStr[j] == aStr[j])
     567             :                                 {
     568           0 :                                     bOk=true;
     569             :                                 }
     570             :                                 else
     571             :                                 {
     572           0 :                                     bOk=false;
     573           0 :                                     break;
     574             :                                 }
     575             :                             }
     576           0 :                         }
     577             :                     }
     578             :                     else
     579             :                     {
     580           0 :                         OUString aQueryStr = rEntry.GetQueryItem().maString.getString();
     581           0 :                         ::com::sun::star::uno::Sequence< sal_Int32 > xOff;
     582             :                         OUString aCell = pTransliteration->transliterate(
     583           0 :                             aCellStr, ScGlobal::eLnge, 0, aCellStr.getLength(), &xOff);
     584             :                         OUString aQuer = pTransliteration->transliterate(
     585           0 :                             aQueryStr, ScGlobal::eLnge, 0, aQueryStr.getLength(), &xOff);
     586           0 :                         bOk = (aCell.indexOf( aQuer ) != -1);
     587             :                     }
     588           0 :                     if (rEntry.eOp == SC_NOT_EQUAL)
     589           0 :                         bOk = !bOk;
     590             :                 }
     591             :                 else
     592             :                 {   // use collator here because data was probably sorted
     593             :                     sal_Int32 nCompare = pCollator->compareString(
     594           0 :                         aCellStr, rEntry.GetQueryItem().maString.getString());
     595           0 :                     switch (rEntry.eOp)
     596             :                     {
     597             :                         case SC_LESS :
     598           0 :                             bOk = (nCompare < 0);
     599           0 :                             break;
     600             :                         case SC_GREATER :
     601           0 :                             bOk = (nCompare > 0);
     602           0 :                             break;
     603             :                         case SC_LESS_EQUAL :
     604           0 :                             bOk = (nCompare <= 0);
     605           0 :                             break;
     606             :                         case SC_GREATER_EQUAL :
     607           0 :                             bOk = (nCompare >= 0);
     608           0 :                             break;
     609             :                         case SC_NOT_EQUAL:
     610             :                             OSL_FAIL("SC_NOT_EQUAL");
     611           0 :                             break;
     612             :                         case SC_TOPVAL:
     613             :                         case SC_BOTVAL:
     614             :                         case SC_TOPPERC:
     615             :                         case SC_BOTPERC:
     616             :                         default:
     617           0 :                             break;
     618             :                     }
     619             :                 }
     620           0 :             }
     621             :         }
     622             : 
     623         412 :         if (nPos == -1)
     624             :         {
     625         222 :             nPos++;
     626         222 :             aPassed[nPos] = bOk;
     627             :         }
     628             :         else
     629             :         {
     630         190 :             if (rEntry.eConnect == SC_AND)
     631             :             {
     632         190 :                 aPassed[nPos] = aPassed[nPos] && bOk;
     633             :             }
     634             :             else
     635             :             {
     636           0 :                 nPos++;
     637           0 :                 aPassed[nPos] = bOk;
     638             :             }
     639             :         }
     640             :     }
     641             : 
     642         222 :     for (long j=1; j <= nPos; j++)
     643           0 :         aPassed[0] = aPassed[0] || aPassed[j];
     644             : 
     645         222 :     bool bRet = aPassed[0];
     646         222 :     return bRet;
     647             : }
     648             : 
     649          32 : ScDocument* ScDPCache::GetDoc() const
     650             : {
     651          32 :     return mpDoc;
     652             : }
     653             : 
     654      190390 : long ScDPCache::GetColumnCount() const
     655             : {
     656      190390 :     return mnColumnCount;
     657             : }
     658             : 
     659          24 : bool ScDPCache::IsRowEmpty(SCROW nRow) const
     660             : {
     661          24 :     bool bEmpty = true;
     662          24 :     maEmptyRows.search_tree(nRow, bEmpty);
     663          24 :     return bEmpty;
     664             : }
     665             : 
     666        1612 : const ScDPCache::GroupItems* ScDPCache::GetGroupItems(long nDim) const
     667             : {
     668        1612 :     if (nDim < 0)
     669           0 :         return NULL;
     670             : 
     671        1612 :     long nSourceCount = static_cast<long>(maFields.size());
     672        1612 :     if (nDim < nSourceCount)
     673        1532 :         return maFields[nDim].mpGroup.get();
     674             : 
     675          80 :     nDim -= nSourceCount;
     676          80 :     if (nDim < static_cast<long>(maGroupFields.size()))
     677          80 :         return &maGroupFields[nDim];
     678             : 
     679           0 :     return NULL;
     680             : }
     681             : 
     682       58418 : OUString ScDPCache::GetDimensionName(LabelsType::size_type nDim) const
     683             : {
     684             :     OSL_ENSURE(nDim < maLabelNames.size()-1 , "ScDPTableDataCache::GetDimensionName");
     685             :     OSL_ENSURE(maLabelNames.size() == static_cast <sal_uInt16> (mnColumnCount+1), "ScDPTableDataCache::GetDimensionName");
     686             : 
     687       58418 :     if ( nDim+1 < maLabelNames.size() )
     688             :     {
     689       58418 :         return maLabelNames[nDim+1];
     690             :     }
     691             :     else
     692           0 :         return OUString();
     693             : }
     694             : 
     695             : namespace {
     696             : 
     697             : typedef boost::unordered_set<OUString, OUStringHash> LabelSet;
     698             : 
     699             : class InsertLabel : public std::unary_function<OUString, void>
     700             : {
     701             :     LabelSet& mrNames;
     702             : public:
     703         410 :     InsertLabel(LabelSet& rNames) : mrNames(rNames) {}
     704        1212 :     void operator() (const OUString& r)
     705             :     {
     706        1212 :         mrNames.insert(r);
     707        1212 :     }
     708             : };
     709             : 
     710             : }
     711             : 
     712         104 : void ScDPCache::PostInit()
     713             : {
     714             :     OSL_ENSURE(!maFields.empty(), "Cache not initialized!");
     715             : 
     716         104 :     maEmptyRows.build_tree();
     717             :     typedef mdds::flat_segment_tree<SCROW, bool>::const_reverse_iterator itr_type;
     718         104 :     itr_type it = maEmptyRows.rbegin();
     719             :     OSL_ENSURE(it != maEmptyRows.rend(), "corrupt flat_segment_tree instance!");
     720         104 :     mnDataSize = maFields[0].maData.size();
     721         104 :     ++it; // Skip the first position.
     722             :     OSL_ENSURE(it != maEmptyRows.rend(), "buggy version of flat_segment_tree is used.");
     723         104 :     if (it->second)
     724             :     {
     725         104 :         SCROW nLastNonEmpty = it->first - 1;
     726         104 :         if (nLastNonEmpty+1 < mnDataSize)
     727           2 :             mnDataSize = nLastNonEmpty+1;
     728             :     }
     729         104 : }
     730             : 
     731         146 : void ScDPCache::Clear()
     732             : {
     733         146 :     mnColumnCount = 0;
     734         146 :     mnRowCount = 0;
     735         146 :     maFields.clear();
     736         146 :     maLabelNames.clear();
     737         146 :     maGroupFields.clear();
     738         146 :     maEmptyRows.clear();
     739         146 :     maStringPool.clear();
     740         146 : }
     741             : 
     742         410 : void ScDPCache::AddLabel(const OUString& rLabel)
     743             : {
     744             : 
     745         410 :     if ( maLabelNames.empty() )
     746         104 :         maLabelNames.push_back(ScGlobal::GetRscString(STR_PIVOT_DATA));
     747             : 
     748             :     //reset name if needed
     749         410 :     LabelSet aExistingNames;
     750         410 :     std::for_each(maLabelNames.begin(), maLabelNames.end(), InsertLabel(aExistingNames));
     751         410 :     sal_Int32 nSuffix = 1;
     752         820 :     OUString aNewName = rLabel;
     753             :     while (true)
     754             :     {
     755         410 :         if (!aExistingNames.count(aNewName))
     756             :         {
     757             :             // unique name found!
     758         410 :             maLabelNames.push_back(aNewName);
     759         820 :             return;
     760             :         }
     761             : 
     762             :         // Name already exists.
     763           0 :         OUStringBuffer aBuf(rLabel);
     764           0 :         aBuf.append(++nSuffix);
     765           0 :         aNewName = aBuf.makeStringAndClear();
     766         410 :     }
     767             : }
     768             : 
     769       17612 : SCROW ScDPCache::GetItemDataId(sal_uInt16 nDim, SCROW nRow, bool bRepeatIfEmpty) const
     770             : {
     771             :     OSL_ENSURE(nDim < mnColumnCount, "ScDPTableDataCache::GetItemDataId ");
     772             : 
     773       17612 :     const Field& rField = maFields[nDim];
     774       17612 :     if (static_cast<size_t>(nRow) >= rField.maData.size())
     775             :     {
     776             :         // nRow is in the trailing empty rows area.
     777         116 :         if (bRepeatIfEmpty)
     778           0 :             nRow = rField.maData.size()-1; // Move to the last non-empty row.
     779             :         else
     780             :             // Return the last item, which should always be empty if the
     781             :             // initialization has skipped trailing empty rows.
     782         116 :             return rField.maItems.size()-1;
     783             : 
     784             :     }
     785       17496 :     else if (bRepeatIfEmpty)
     786             :     {
     787          48 :         while (nRow > 0 && rField.maItems[rField.maData[nRow]].IsEmpty())
     788           0 :             --nRow;
     789             :     }
     790             : 
     791       17496 :     return rField.maData[nRow];
     792             : }
     793             : 
     794       26192 : const ScDPItemData* ScDPCache::GetItemDataById(long nDim, SCROW nId) const
     795             : {
     796       26192 :     if (nDim < 0 || nId < 0)
     797           0 :         return NULL;
     798             : 
     799       26192 :     size_t nSourceCount = maFields.size();
     800       26192 :     size_t nDimPos = static_cast<size_t>(nDim);
     801       26192 :     size_t nItemId = static_cast<size_t>(nId);
     802       26192 :     if (nDimPos < nSourceCount)
     803             :     {
     804             :         // source field.
     805       25464 :         const Field& rField = maFields[nDimPos];
     806       25464 :         if (nItemId < rField.maItems.size())
     807       23670 :             return &rField.maItems[nItemId];
     808             : 
     809        1794 :         if (!rField.mpGroup)
     810           6 :             return NULL;
     811             : 
     812        1788 :         nItemId -= rField.maItems.size();
     813        1788 :         const ItemsType& rGI = rField.mpGroup->maItems;
     814        1788 :         if (nItemId >= rGI.size())
     815           0 :             return NULL;
     816             : 
     817        1788 :         return &rGI[nItemId];
     818             :     }
     819             : 
     820             :     // Try group fields.
     821         728 :     nDimPos -= nSourceCount;
     822         728 :     if (nDimPos >= maGroupFields.size())
     823         108 :         return NULL;
     824             : 
     825         620 :     const ItemsType& rGI = maGroupFields[nDimPos].maItems;
     826         620 :     if (nItemId >= rGI.size())
     827           0 :         return NULL;
     828             : 
     829         620 :     return &rGI[nItemId];
     830             : }
     831             : 
     832          22 : size_t ScDPCache::GetFieldCount() const
     833             : {
     834          22 :     return maFields.size();
     835             : }
     836             : 
     837           2 : size_t ScDPCache::GetGroupFieldCount() const
     838             : {
     839           2 :     return maGroupFields.size();
     840             : }
     841             : 
     842        1422 : SCROW ScDPCache::GetRowCount() const
     843             : {
     844        1422 :     return mnRowCount;
     845             : }
     846             : 
     847         708 : SCROW ScDPCache::GetDataSize() const
     848             : {
     849             :     OSL_ENSURE(mnDataSize <= GetRowCount(), "Data size should never be larger than the row count.");
     850         708 :     return mnDataSize >= 0 ? mnDataSize : 0;
     851             : }
     852             : 
     853          68 : const ScDPCache::IndexArrayType* ScDPCache::GetFieldIndexArray( size_t nDim ) const
     854             : {
     855          68 :     if (nDim >= maFields.size())
     856           0 :         return NULL;
     857             : 
     858          68 :     return &maFields[nDim].maData;
     859             : }
     860             : 
     861          60 : const ScDPCache::ItemsType& ScDPCache::GetDimMemberValues(SCCOL nDim) const
     862             : {
     863             :     OSL_ENSURE( nDim>=0 && nDim < mnColumnCount ," nDim < mnColumnCount ");
     864          60 :     return maFields.at(nDim).maItems;
     865             : }
     866             : 
     867        6854 : sal_uLong ScDPCache::GetNumberFormat( long nDim ) const
     868             : {
     869        6854 :     if ( nDim >= mnColumnCount )
     870           0 :         return 0;
     871             : 
     872             :     // TODO: Find a way to determine the dominant number format in presence of
     873             :     // multiple number formats in the same field.
     874        6854 :     return maFields[nDim].mnNumFormat;
     875             : }
     876             : 
     877        3494 : bool ScDPCache::IsDateDimension( long nDim ) const
     878             : {
     879        3494 :     if (nDim >= mnColumnCount)
     880           0 :         return false;
     881             : 
     882        3494 :     SvNumberFormatter* pFormatter = mpDoc->GetFormatTable();
     883        3494 :     if (!pFormatter)
     884           0 :         return false;
     885             : 
     886        3494 :     short eType = pFormatter->GetType(maFields[nDim].mnNumFormat);
     887        3494 :     return (eType == NUMBERFORMAT_DATE) || (eType == NUMBERFORMAT_DATETIME);
     888             : }
     889             : 
     890        1454 : long ScDPCache::GetDimMemberCount(long nDim) const
     891             : {
     892             :     OSL_ENSURE( nDim>=0 && nDim < mnColumnCount ," ScDPTableDataCache::GetDimMemberCount : out of bound ");
     893        1454 :     return maFields[nDim].maItems.size();
     894             : }
     895             : 
     896          38 : SCCOL ScDPCache::GetDimensionIndex(const OUString& sName) const
     897             : {
     898          78 :     for (size_t i = 1; i < maLabelNames.size(); ++i)
     899             :     {
     900          78 :         if (maLabelNames[i].equals(sName))
     901          38 :             return static_cast<SCCOL>(i-1);
     902             :     }
     903           0 :     return -1;
     904             : }
     905             : 
     906        1738 : const OUString* ScDPCache::InternString(const OUString& rStr) const
     907             : {
     908        1738 :     StringSetType::iterator it = maStringPool.find(rStr);
     909        1738 :     if (it != maStringPool.end())
     910             :         // In the pool.
     911        1262 :         return &(*it);
     912             : 
     913         476 :     std::pair<StringSetType::iterator, bool> r = maStringPool.insert(rStr);
     914         476 :     return r.second ? &(*r.first) : NULL;
     915             : }
     916             : 
     917         186 : void ScDPCache::AddReference(ScDPObject* pObj) const
     918             : {
     919         186 :     maRefObjects.insert(pObj);
     920         186 : }
     921             : 
     922         186 : void ScDPCache::RemoveReference(ScDPObject* pObj) const
     923             : {
     924         186 :     if (mbDisposing)
     925             :         // Object being deleted.
     926         216 :         return;
     927             : 
     928         156 :     maRefObjects.erase(pObj);
     929         156 :     if (maRefObjects.empty())
     930         110 :         mpDoc->GetDPCollection()->RemoveCache(this);
     931             : }
     932             : 
     933          10 : const ScDPCache::ObjectSetType& ScDPCache::GetAllReferences() const
     934             : {
     935          10 :     return maRefObjects;
     936             : }
     937             : 
     938         200 : SCROW ScDPCache::GetIdByItemData(long nDim, const ScDPItemData& rItem) const
     939             : {
     940         200 :     if (nDim < 0)
     941           0 :         return -1;
     942             : 
     943         200 :     if (nDim < mnColumnCount)
     944             :     {
     945             :         // source field.
     946          68 :         const ItemsType& rItems = maFields[nDim].maItems;
     947         900 :         for (size_t i = 0, n = rItems.size(); i < n; ++i)
     948             :         {
     949         832 :             if (rItems[i] == rItem)
     950           0 :                 return i;
     951             :         }
     952             : 
     953          68 :         if (!maFields[nDim].mpGroup)
     954           0 :             return -1;
     955             : 
     956             :         // grouped source field.
     957          68 :         const ItemsType& rGI = maFields[nDim].mpGroup->maItems;
     958         260 :         for (size_t i = 0, n = rGI.size(); i < n; ++i)
     959             :         {
     960         260 :             if (rGI[i] == rItem)
     961          68 :                 return rItems.size() + i;
     962             :         }
     963           0 :         return -1;
     964             :     }
     965             : 
     966             :     // group field.
     967         132 :     nDim -= mnColumnCount;
     968         132 :     if (static_cast<size_t>(nDim) < maGroupFields.size())
     969             :     {
     970         132 :         const ItemsType& rGI = maGroupFields[nDim].maItems;
     971         220 :         for (size_t i = 0, n = rGI.size(); i < n; ++i)
     972             :         {
     973         220 :             if (rGI[i] == rItem)
     974         132 :                 return i;
     975             :         }
     976             :     }
     977             : 
     978           0 :     return -1;
     979             : }
     980             : 
     981        9434 : OUString ScDPCache::GetFormattedString(long nDim, const ScDPItemData& rItem) const
     982             : {
     983        9434 :     if (nDim < 0)
     984         236 :         return rItem.GetString();
     985             : 
     986        9198 :     ScDPItemData::Type eType = rItem.GetType();
     987        9198 :     if (eType == ScDPItemData::Value)
     988             :     {
     989             :         // Format value using the stored number format.
     990        5824 :         sal_uLong nNumFormat = GetNumberFormat(nDim);
     991        5824 :         SvNumberFormatter* pFormatter = mpDoc->GetFormatTable();
     992        5824 :         if (pFormatter)
     993             :         {
     994        5824 :             Color* pColor = NULL;
     995        5824 :             OUString aStr;
     996        5824 :             pFormatter->GetOutputString(rItem.GetValue(), nNumFormat, aStr, &pColor);
     997        5824 :             return aStr;
     998             :         }
     999             :     }
    1000             : 
    1001        3374 :     if (eType == ScDPItemData::GroupValue)
    1002             :     {
    1003        1592 :         ScDPItemData::GroupValueAttr aAttr = rItem.GetGroupValue();
    1004        1592 :         double fStart = 0.0, fEnd = 0.0;
    1005        1592 :         const GroupItems* p = GetGroupItems(nDim);
    1006        1592 :         if (p)
    1007             :         {
    1008        1592 :             fStart = p->maInfo.mfStart;
    1009        1592 :             fEnd = p->maInfo.mfEnd;
    1010             :         }
    1011             :         return ScDPUtil::getDateGroupName(
    1012        1592 :             aAttr.mnGroupType, aAttr.mnValue, mpDoc->GetFormatTable(), fStart, fEnd);
    1013             :     }
    1014             : 
    1015        1782 :     if (eType == ScDPItemData::RangeStart)
    1016             :     {
    1017          20 :         double fVal = rItem.GetValue();
    1018          20 :         const GroupItems* p = GetGroupItems(nDim);
    1019          20 :         if (!p)
    1020           0 :             return rItem.GetString();
    1021             : 
    1022          20 :         sal_Unicode cDecSep = ScGlobal::pLocaleData->getNumDecimalSep()[0];
    1023          20 :         return ScDPUtil::getNumGroupName(fVal, p->maInfo, cDecSep, mpDoc->GetFormatTable());
    1024             :     }
    1025             : 
    1026        1762 :     return rItem.GetString();
    1027             : }
    1028             : 
    1029          24 : long ScDPCache::AppendGroupField()
    1030             : {
    1031          24 :     maGroupFields.push_back(new GroupItems);
    1032          24 :     return static_cast<long>(maFields.size() + maGroupFields.size() - 1);
    1033             : }
    1034             : 
    1035          36 : void ScDPCache::ResetGroupItems(long nDim, const ScDPNumGroupInfo& rNumInfo, sal_Int32 nGroupType)
    1036             : {
    1037          36 :     if (nDim < 0)
    1038           0 :         return;
    1039             : 
    1040          36 :     long nSourceCount = static_cast<long>(maFields.size());
    1041          36 :     if (nDim < nSourceCount)
    1042             :     {
    1043          12 :         maFields.at(nDim).mpGroup.reset(new GroupItems(rNumInfo, nGroupType));
    1044          12 :         return;
    1045             :     }
    1046             : 
    1047          24 :     nDim -= nSourceCount;
    1048          24 :     if (nDim < static_cast<long>(maGroupFields.size()))
    1049             :     {
    1050          24 :         GroupItems& rGI = maGroupFields[nDim];
    1051          24 :         rGI.maItems.clear();
    1052          24 :         rGI.maInfo = rNumInfo;
    1053          24 :         rGI.mnGroupType = nGroupType;
    1054             :     }
    1055             : }
    1056             : 
    1057        1660 : SCROW ScDPCache::SetGroupItem(long nDim, const ScDPItemData& rData)
    1058             : {
    1059        1660 :     if (nDim < 0)
    1060           0 :         return -1;
    1061             : 
    1062        1660 :     long nSourceCount = static_cast<long>(maFields.size());
    1063        1660 :     if (nDim < nSourceCount)
    1064             :     {
    1065        1548 :         GroupItems& rGI = *maFields.at(nDim).mpGroup;
    1066        1548 :         rGI.maItems.push_back(rData);
    1067        1548 :         SCROW nId = maFields[nDim].maItems.size() + rGI.maItems.size() - 1;
    1068        1548 :         return nId;
    1069             :     }
    1070             : 
    1071         112 :     nDim -= nSourceCount;
    1072         112 :     if (nDim < static_cast<long>(maGroupFields.size()))
    1073             :     {
    1074         112 :         ItemsType& rItems = maGroupFields.at(nDim).maItems;
    1075         112 :         rItems.push_back(rData);
    1076         112 :         return rItems.size()-1;
    1077             :     }
    1078             : 
    1079           0 :     return -1;
    1080             : }
    1081             : 
    1082          38 : void ScDPCache::GetGroupDimMemberIds(long nDim, std::vector<SCROW>& rIds) const
    1083             : {
    1084          38 :     if (nDim < 0)
    1085           0 :         return;
    1086             : 
    1087          38 :     long nSourceCount = static_cast<long>(maFields.size());
    1088          38 :     if (nDim < nSourceCount)
    1089             :     {
    1090          10 :         if (!maFields.at(nDim).mpGroup)
    1091           0 :             return;
    1092             : 
    1093          10 :         size_t nOffset = maFields[nDim].maItems.size();
    1094          10 :         const ItemsType& rGI = maFields[nDim].mpGroup->maItems;
    1095        1548 :         for (size_t i = 0, n = rGI.size(); i < n; ++i)
    1096        1538 :             rIds.push_back(static_cast<SCROW>(i + nOffset));
    1097             : 
    1098          10 :         return;
    1099             :     }
    1100             : 
    1101          28 :     nDim -= nSourceCount;
    1102          28 :     if (nDim < static_cast<long>(maGroupFields.size()))
    1103             :     {
    1104          28 :         const ItemsType& rGI = maGroupFields.at(nDim).maItems;
    1105         176 :         for (size_t i = 0, n = rGI.size(); i < n; ++i)
    1106         148 :             rIds.push_back(static_cast<SCROW>(i));
    1107             :     }
    1108             : }
    1109             : 
    1110             : namespace {
    1111             : 
    1112             : struct ClearGroupItems : std::unary_function<ScDPCache::Field, void>
    1113             : {
    1114          56 :     void operator() (ScDPCache::Field& r) const
    1115             :     {
    1116          56 :         r.mpGroup.reset();
    1117          56 :     }
    1118             : };
    1119             : 
    1120             : }
    1121             : 
    1122          16 : void ScDPCache::ClearGroupFields()
    1123             : {
    1124          16 :     maGroupFields.clear();
    1125          16 :     std::for_each(maFields.begin(), maFields.end(), ClearGroupItems());
    1126          16 : }
    1127             : 
    1128         320 : const ScDPNumGroupInfo* ScDPCache::GetNumGroupInfo(long nDim) const
    1129             : {
    1130         320 :     if (nDim < 0)
    1131           0 :         return NULL;
    1132             : 
    1133         320 :     long nSourceCount = static_cast<long>(maFields.size());
    1134         320 :     if (nDim < nSourceCount)
    1135             :     {
    1136         188 :         if (!maFields.at(nDim).mpGroup)
    1137         118 :             return NULL;
    1138             : 
    1139          70 :         return &maFields[nDim].mpGroup->maInfo;
    1140             :     }
    1141             : 
    1142         132 :     nDim -= nSourceCount;
    1143         132 :     if (nDim < static_cast<long>(maGroupFields.size()))
    1144         132 :         return &maGroupFields.at(nDim).maInfo;
    1145             : 
    1146           0 :     return NULL;
    1147             : }
    1148             : 
    1149         102 : sal_Int32 ScDPCache::GetGroupType(long nDim) const
    1150             : {
    1151         102 :     if (nDim < 0)
    1152           0 :         return 0;
    1153             : 
    1154         102 :     long nSourceCount = static_cast<long>(maFields.size());
    1155         102 :     if (nDim < nSourceCount)
    1156             :     {
    1157          34 :         if (!maFields.at(nDim).mpGroup)
    1158           0 :             return 0;
    1159             : 
    1160          34 :         return maFields[nDim].mpGroup->mnGroupType;
    1161             :     }
    1162             : 
    1163          68 :     nDim -= nSourceCount;
    1164          68 :     if (nDim < static_cast<long>(maGroupFields.size()))
    1165          68 :         return maGroupFields.at(nDim).mnGroupType;
    1166             : 
    1167           0 :     return 0;
    1168             : }
    1169             : 
    1170       17246 : SCROW ScDPCache::GetOrder(long /*nDim*/, SCROW nIndex) const
    1171             : {
    1172       17246 :     return nIndex;
    1173             : }
    1174             : 
    1175         228 : ;
    1176             : 
    1177             : #if DEBUG_PIVOT_TABLE
    1178             : 
    1179             : namespace {
    1180             : 
    1181             : std::ostream& operator<< (::std::ostream& os, const OUString& str)
    1182             : {
    1183             :     return os << OUStringToOString(str, RTL_TEXTENCODING_UTF8).getStr();
    1184             : }
    1185             : 
    1186             : void dumpItems(const ScDPCache& rCache, long nDim, const ScDPCache::ItemsType& rItems, size_t nOffset)
    1187             : {
    1188             :     for (size_t i = 0; i < rItems.size(); ++i)
    1189             :         cout << "      " << (i+nOffset) << ": " << rCache.GetFormattedString(nDim, rItems[i]) << endl;
    1190             : }
    1191             : 
    1192             : void dumpSourceData(const ScDPCache& rCache, long nDim, const ScDPCache::ItemsType& rItems, const ScDPCache::IndexArrayType& rArray)
    1193             : {
    1194             :     ScDPCache::IndexArrayType::const_iterator it = rArray.begin(), itEnd = rArray.end();
    1195             :     for (; it != itEnd; ++it)
    1196             :         cout << "      '" << rCache.GetFormattedString(nDim, rItems[*it]) << "'" << endl;
    1197             : }
    1198             : 
    1199             : const char* getGroupTypeName(sal_Int32 nType)
    1200             : {
    1201             :     static const char* pNames[] = {
    1202             :         "", "years", "quarters", "months", "days", "hours", "minutes", "seconds"
    1203             :     };
    1204             : 
    1205             :     switch (nType)
    1206             :     {
    1207             :         case sheet::DataPilotFieldGroupBy::YEARS:    return pNames[1];
    1208             :         case sheet::DataPilotFieldGroupBy::QUARTERS: return pNames[2];
    1209             :         case sheet::DataPilotFieldGroupBy::MONTHS:   return pNames[3];
    1210             :         case sheet::DataPilotFieldGroupBy::DAYS:     return pNames[4];
    1211             :         case sheet::DataPilotFieldGroupBy::HOURS:    return pNames[5];
    1212             :         case sheet::DataPilotFieldGroupBy::MINUTES:  return pNames[6];
    1213             :         case sheet::DataPilotFieldGroupBy::SECONDS:  return pNames[7];
    1214             :         default:
    1215             :             ;
    1216             :     }
    1217             : 
    1218             :     return pNames[0];
    1219             : }
    1220             : 
    1221             : }
    1222             : 
    1223             : void ScDPCache::Dump() const
    1224             : {
    1225             :     // Change these flags to fit your debugging needs.
    1226             :     bool bDumpItems = false;
    1227             :     bool bDumpSourceData = false;
    1228             : 
    1229             :     cout << "--- pivot cache dump" << endl;
    1230             :     {
    1231             :         FieldsType::const_iterator it = maFields.begin(), itEnd = maFields.end();
    1232             :         for (size_t i = 0; it != itEnd; ++it, ++i)
    1233             :         {
    1234             :             const Field& fld = *it;
    1235             :             cout << "* source dimension: " << GetDimensionName(i) << " (ID = " << i << ")" << endl;
    1236             :             cout << "    item count: " << fld.maItems.size() << endl;
    1237             :             if (bDumpItems)
    1238             :                 dumpItems(*this, i, fld.maItems, 0);
    1239             :             if (fld.mpGroup)
    1240             :             {
    1241             :                 cout << "    group item count: " << fld.mpGroup->maItems.size() << endl;
    1242             :                 cout << "    group type: " << getGroupTypeName(fld.mpGroup->mnGroupType) << endl;
    1243             :                 if (bDumpItems)
    1244             :                     dumpItems(*this, i, fld.mpGroup->maItems, fld.maItems.size());
    1245             :             }
    1246             : 
    1247             :             if (bDumpSourceData)
    1248             :             {
    1249             :                 cout << "    source data (re-constructed):" << endl;
    1250             :                 dumpSourceData(*this, i, fld.maItems, fld.maData);
    1251             :             }
    1252             :         }
    1253             :     }
    1254             : 
    1255             :     {
    1256             :         GroupFieldsType::const_iterator it = maGroupFields.begin(), itEnd = maGroupFields.end();
    1257             :         for (size_t i = maFields.size(); it != itEnd; ++it, ++i)
    1258             :         {
    1259             :             const GroupItems& gi = *it;
    1260             :             cout << "* group dimension: (unnamed) (ID = " << i << ")" << endl;
    1261             :             cout << "    item count: " << gi.maItems.size() << endl;
    1262             :             cout << "    group type: " << getGroupTypeName(gi.mnGroupType) << endl;
    1263             :             if (bDumpItems)
    1264             :                 dumpItems(*this, i, gi.maItems, 0);
    1265             :         }
    1266             :     }
    1267             : 
    1268             :     {
    1269             :         struct { SCROW start; SCROW end; bool empty; } aRange;
    1270             :         cout << "* empty rows: " << endl;
    1271             :         mdds::flat_segment_tree<SCROW, bool>::const_iterator it = maEmptyRows.begin(), itEnd = maEmptyRows.end();
    1272             :         if (it != itEnd)
    1273             :         {
    1274             :             aRange.start = it->first;
    1275             :             aRange.empty = it->second;
    1276             :             ++it;
    1277             :         }
    1278             : 
    1279             :         for (; it != itEnd; ++it)
    1280             :         {
    1281             :             aRange.end = it->first-1;
    1282             :             cout << "    rows " << aRange.start << "-" << aRange.end << ": " << (aRange.empty ? "empty" : "not-empty") << endl;
    1283             :             aRange.start = it->first;
    1284             :             aRange.empty = it->second;
    1285             :         }
    1286             :     }
    1287             : 
    1288             :     cout << "---" << endl;
    1289             : }
    1290             : 
    1291             : #endif
    1292             : 
    1293             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10