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: */
|
