sc/source/core/data/dpgroup.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * 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 "dpgroup.hxx"
  21
  22 #include "global.hxx"
  23 #include "document.hxx"
  24 #include "dpfilteredcache.hxx"
  25 #include "dptabsrc.hxx"
  26 #include "dptabres.hxx"
  27 #include "dpobject.hxx"
  28 #include "dpglobal.hxx"
  29 #include "dputil.hxx"
  30 #include "globalnames.hxx"
  31
  32 #include <rtl/math.hxx>
  33
  34 #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
  35 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
  36 #include <com/sun/star/i18n/CalendarDisplayIndex.hpp>
  37
  38 #include <vector>
  39 #include <boost/unordered_map.hpp>
  40 #include <boost/unordered_set.hpp>
  41
  42 using namespace ::com::sun::star;
  43 using ::com::sun::star::uno::Any;
  44 using ::com::sun::star::uno::Reference;
  45 using ::com::sun::star::uno::Sequence;
  46 using ::com::sun::star::uno::UNO_QUERY;
  47 using ::com::sun::star::uno::UNO_QUERY_THROW;
  48
  49 using ::std::vector;
  50 using ::boost::shared_ptr;
  51
  52 const sal_uInt16 SC_DP_LEAPYEAR = 1648;     // arbitrary leap year for date calculations
  53
  54 class ScDPGroupNumFilter : public ScDPFilteredCache::FilterBase
  55 {
  56 public:
  57     ScDPGroupNumFilter(const std::vector<ScDPItemData>& rValues, const ScDPNumGroupInfo& rInfo);
  58     virtual ~ScDPGroupNumFilter() {}
  59     virtual bool match(const ScDPItemData &rCellData) const;
  60     virtual std::vector<ScDPItemData> getMatchValues() const;
  61 private:
  62     std::vector<ScDPItemData> maValues;
  63     ScDPNumGroupInfo maNumInfo;
  64 };
  65
  66 ScDPGroupNumFilter::ScDPGroupNumFilter(const std::vector<ScDPItemData>& rValues, const ScDPNumGroupInfo& rInfo) :
  67     maValues(rValues), maNumInfo(rInfo) {}
  68
  69 bool ScDPGroupNumFilter::match(const ScDPItemData& rCellData) const
  70 {
  71     if (rCellData.GetType() != ScDPItemData::Value)
  72         return false;
  73
  74     std::vector<ScDPItemData>::const_iterator it = maValues.begin(), itEnd = maValues.end();
  75     for (; it != itEnd; ++it)
  76     {
  77         double fVal = it->GetValue();
  78         if (rtl::math::isInf(fVal))
  79         {
  80             if (rtl::math::isSignBitSet(fVal))
  81             {
  82                 // Less than the min value.
  83                 if (rCellData.GetValue() < maNumInfo.mfStart)
  84                     return true;
  85             }
  86
  87             // Greater than the max value.
  88             if (maNumInfo.mfEnd < rCellData.GetValue())
  89                 return true;
  90
  91             continue;
  92         }
  93
  94         double low = fVal;
  95         double high = low + maNumInfo.mfStep;
  96         if (maNumInfo.mbIntegerOnly)
  97             high += 1.0;
  98
  99         if (low <= rCellData.GetValue() && rCellData.GetValue() < high)
 100             return true;
 101     }
 102
 103     return false;
 104 }
 105
 106 std::vector<ScDPItemData> ScDPGroupNumFilter::getMatchValues() const
 107 {
 108     return std::vector<ScDPItemData>();
 109 }
 110
 111 class ScDPGroupDateFilter : public ScDPFilteredCache::FilterBase
 112 {
 113 public:
 114     virtual ~ScDPGroupDateFilter() {}
 115     ScDPGroupDateFilter(
 116         const std::vector<ScDPItemData>& rValues, const Date& rNullDate, const ScDPNumGroupInfo& rNumInfo);
 117
 118     virtual bool match(const ScDPItemData & rCellData) const;
 119     virtual std::vector<ScDPItemData> getMatchValues() const;
 120
 121 private:
 122     ScDPGroupDateFilter(); // disabled
 123
 124     std::vector<ScDPItemData> maValues;
 125     Date             maNullDate;
 126     ScDPNumGroupInfo maNumInfo;
 127 };
 128
 129 // ----------------------------------------------------------------------------
 130
 131 ScDPGroupDateFilter::ScDPGroupDateFilter(
 132     const std::vector<ScDPItemData>& rValues, const Date& rNullDate, const ScDPNumGroupInfo& rNumInfo) :
 133     maValues(rValues),
 134     maNullDate(rNullDate),
 135     maNumInfo(rNumInfo)
 136 {
 137 }
 138
 139 bool ScDPGroupDateFilter::match( const ScDPItemData & rCellData ) const
 140 {
 141     using namespace ::com::sun::star::sheet;
 142     using ::rtl::math::approxFloor;
 143     using ::rtl::math::approxEqual;
 144
 145     if ( !rCellData.IsValue() )
 146         return false;
 147
 148     std::vector<ScDPItemData>::const_iterator it = maValues.begin(), itEnd = maValues.end();
 149     for (; it != itEnd; ++it)
 150     {
 151         const ScDPItemData& rValue = *it;
 152         if (rValue.GetType() != ScDPItemData::GroupValue)
 153             continue;
 154
 155         sal_Int32 nGroupType = rValue.GetGroupValue().mnGroupType;
 156         sal_Int32 nValue = rValue.GetGroupValue().mnValue;
 157
 158         // Start and end dates are inclusive.  (An end date without a time value
 159         // is included, while an end date with a time value is not.)
 160
 161         if (rCellData.GetValue() < maNumInfo.mfStart && !approxEqual(rCellData.GetValue(), maNumInfo.mfStart))
 162         {
 163             if (nValue == ScDPItemData::DateFirst)
 164                 return true;
 165             continue;
 166         }
 167
 168         if (rCellData.GetValue() > maNumInfo.mfEnd && !approxEqual(rCellData.GetValue(), maNumInfo.mfEnd))
 169         {
 170             if (nValue == ScDPItemData::DateLast)
 171                 return true;
 172             continue;
 173         }
 174
 175         if (nGroupType == DataPilotFieldGroupBy::HOURS || nGroupType == DataPilotFieldGroupBy::MINUTES ||
 176             nGroupType == DataPilotFieldGroupBy::SECONDS)
 177         {
 178             // handle time
 179             // (as in the cell functions, ScInterpreter::ScGetHour etc.: seconds are rounded)
 180
 181             double time = rCellData.GetValue() - approxFloor(rCellData.GetValue());
 182             long seconds = static_cast<long>(approxFloor(time*DATE_TIME_FACTOR + 0.5));
 183
 184             switch (nGroupType)
 185             {
 186                 case DataPilotFieldGroupBy::HOURS:
 187                 {
 188                     sal_Int32 hrs = seconds / 3600;
 189                     if (hrs == nValue)
 190                         return true;
 191                 }
 192                 break;
 193                 case DataPilotFieldGroupBy::MINUTES:
 194                 {
 195                     sal_Int32 minutes = (seconds % 3600) / 60;
 196                     if (minutes == nValue)
 197                         return true;
 198                 }
 199                 break;
 200                 case DataPilotFieldGroupBy::SECONDS:
 201                 {
 202                     sal_Int32 sec = seconds % 60;
 203                     if (sec == nValue)
 204                         return true;
 205                 }
 206                 break;
 207                 default:
 208                     OSL_FAIL("invalid time part");
 209             }
 210
 211             continue;
 212         }
 213
 214         Date date = maNullDate + static_cast<long>(approxFloor(rCellData.GetValue()));
 215         switch (nGroupType)
 216         {
 217             case DataPilotFieldGroupBy::YEARS:
 218             {
 219                 sal_Int32 year = static_cast<sal_Int32>(date.GetYear());
 220                 if (year == nValue)
 221                     return true;
 222             }
 223             break;
 224             case DataPilotFieldGroupBy::QUARTERS:
 225             {
 226                 sal_Int32 qtr =  1 + (static_cast<sal_Int32>(date.GetMonth()) - 1) / 3;
 227                 if (qtr == nValue)
 228                     return true;
 229             }
 230             break;
 231             case DataPilotFieldGroupBy::MONTHS:
 232             {
 233                 sal_Int32 month = static_cast<sal_Int32>(date.GetMonth());
 234                 if (month == nValue)
 235                     return true;
 236             }
 237             break;
 238             case DataPilotFieldGroupBy::DAYS:
 239             {
 240                 Date yearStart(1, 1, date.GetYear());
 241                 sal_Int32 days = (date - yearStart) + 1;       // Jan 01 has value 1
 242                 if (days >= 60 && !date.IsLeapYear())
 243                 {
 244                     // This is not a leap year.  Adjust the value accordingly.
 245                     ++days;
 246                 }
 247                 if (days == nValue)
 248                     return true;
 249             }
 250             break;
 251             default:
 252                 OSL_FAIL("invalid date part");
 253         }
 254     }
 255
 256     return false;
 257 }
 258
 259 std::vector<ScDPItemData> ScDPGroupDateFilter::getMatchValues() const
 260 {
 261     return std::vector<ScDPItemData>();
 262 }
 263
 264 namespace {
 265
 266 bool isDateInGroup(const ScDPItemData& rGroupItem, const ScDPItemData& rChildItem)
 267 {
 268     if (rGroupItem.GetType() != ScDPItemData::GroupValue || rChildItem.GetType() != ScDPItemData::GroupValue)
 269         return false;
 270
 271     sal_Int32 nGroupPart = rGroupItem.GetGroupValue().mnGroupType;
 272     sal_Int32 nGroupValue = rGroupItem.GetGroupValue().mnValue;
 273     sal_Int32 nChildPart = rChildItem.GetGroupValue().mnGroupType;
 274     sal_Int32 nChildValue = rChildItem.GetGroupValue().mnValue;
 275
 276     if (nGroupValue == ScDPItemData::DateFirst || nGroupValue == ScDPItemData::DateLast ||
 277         nChildValue == ScDPItemData::DateFirst || nChildValue == ScDPItemData::DateLast)
 278     {
 279         // first/last entry matches only itself
 280         return nGroupValue == nChildValue;
 281     }
 282
 283     switch (nChildPart)        // inner part
 284     {
 285         case com::sun::star::sheet::DataPilotFieldGroupBy::MONTHS:
 286             // a month is only contained in its quarter
 287             if (nGroupPart == com::sun::star::sheet::DataPilotFieldGroupBy::QUARTERS)
 288                 // months and quarters are both 1-based
 289                 return (nGroupValue - 1 == (nChildValue - 1) / 3);
 290
 291         case com::sun::star::sheet::DataPilotFieldGroupBy::DAYS:
 292             // a day is only contained in its quarter or month
 293             if (nGroupPart == com::sun::star::sheet::DataPilotFieldGroupBy::MONTHS ||
 294                 nGroupPart == com::sun::star::sheet::DataPilotFieldGroupBy::QUARTERS)
 295             {
 296                 Date aDate(1, 1, SC_DP_LEAPYEAR);
 297                 aDate += (nChildValue - 1);            // days are 1-based
 298                 sal_Int32 nCompare = aDate.GetMonth();
 299                 if (nGroupPart == com::sun::star::sheet::DataPilotFieldGroupBy::QUARTERS)
 300                     nCompare = ( ( nCompare - 1 ) / 3 ) + 1;    // get quarter from date
 301
 302                 return nGroupValue == nCompare;
 303             }
 304             break;
 305         default:
 306             ;
 307     }
 308
 309     return true;
 310 }
 311
 312 }
 313
 314 ScDPGroupItem::ScDPGroupItem( const ScDPItemData& rName ) :
 315     aGroupName( rName )
 316 {
 317 }
 318
 319 ScDPGroupItem::~ScDPGroupItem()
 320 {
 321 }
 322
 323 void ScDPGroupItem::AddElement( const ScDPItemData& rName )
 324 {
 325     aElements.push_back( rName );
 326 }
 327
 328 bool ScDPGroupItem::HasElement( const ScDPItemData& rData ) const
 329 {
 330     for ( ScDPItemDataVec::const_iterator aIter(aElements.begin()); aIter != aElements.end(); ++aIter )
 331         if ( aIter->IsCaseInsEqual( rData ) )
 332             return true;
 333
 334     return false;
 335 }
 336
 337 bool ScDPGroupItem::HasCommonElement( const ScDPGroupItem& rOther ) const
 338 {
 339     for ( ScDPItemDataVec::const_iterator aIter(aElements.begin()); aIter != aElements.end(); ++aIter )
 340         if ( rOther.HasElement( *aIter ) )
 341             return true;
 342
 343     return false;
 344 }
 345
 346 void ScDPGroupItem::FillGroupFilter( ScDPFilteredCache::GroupFilter& rFilter ) const
 347 {
 348     ScDPItemDataVec::const_iterator itrEnd = aElements.end();
 349     for (ScDPItemDataVec::const_iterator itr = aElements.begin(); itr != itrEnd; ++itr)
 350         rFilter.addMatchItem(*itr);
 351 }
 352
 353 // -----------------------------------------------------------------------
 354
 355 ScDPGroupDimension::ScDPGroupDimension( long nSource, const OUString& rNewName ) :
 356     nSourceDim( nSource ),
 357     nGroupDim( -1 ),
 358     aGroupName( rNewName ),
 359     mbDateDimension(false)
 360 {
 361 }
 362
 363 ScDPGroupDimension::~ScDPGroupDimension()
 364 {
 365     maMemberEntries.clear();
 366 }
 367
 368 ScDPGroupDimension::ScDPGroupDimension( const ScDPGroupDimension& rOther ) :
 369     nSourceDim( rOther.nSourceDim ),
 370     nGroupDim( rOther.nGroupDim ),
 371     aGroupName( rOther.aGroupName ),
 372     aItems( rOther.aItems ),
 373     mbDateDimension(rOther.mbDateDimension)
 374 {
 375 }
 376
 377 ScDPGroupDimension& ScDPGroupDimension::operator=( const ScDPGroupDimension& rOther )
 378 {
 379     nSourceDim = rOther.nSourceDim;
 380     nGroupDim  = rOther.nGroupDim;
 381     aGroupName = rOther.aGroupName;
 382     aItems     = rOther.aItems;
 383     mbDateDimension = rOther.mbDateDimension;
 384     return *this;
 385 }
 386
 387 void ScDPGroupDimension::AddItem( const ScDPGroupItem& rItem )
 388 {
 389     aItems.push_back( rItem );
 390 }
 391
 392 void ScDPGroupDimension::SetGroupDim( long nDim )
 393 {
 394     nGroupDim = nDim;
 395 }
 396
 397 const std::vector<SCROW>& ScDPGroupDimension::GetColumnEntries(
 398     const ScDPFilteredCache& rCacheTable) const
 399 {
 400     if (!maMemberEntries.empty())
 401         return maMemberEntries;
 402
 403     rCacheTable.getCache()->GetGroupDimMemberIds(nGroupDim, maMemberEntries);
 404     return maMemberEntries;
 405 }
 406
 407
 408
 409 const ScDPGroupItem* ScDPGroupDimension::GetGroupForData( const ScDPItemData& rData ) const
 410 {
 411     for (ScDPGroupItemVec::const_iterator aIter = aItems.begin(); aIter != aItems.end(); ++aIter)
 412         if (aIter->HasElement(rData))
 413             return &*aIter;
 414
 415     return NULL;
 416 }
 417
 418 const ScDPGroupItem* ScDPGroupDimension::GetGroupForName( const ScDPItemData& rName ) const
 419 {
 420     for ( ScDPGroupItemVec::const_iterator aIter(aItems.begin()); aIter != aItems.end(); ++aIter )
 421         if ( aIter->GetName().IsCaseInsEqual( rName ) )
 422             return &*aIter;
 423
 424     return NULL;
 425 }
 426
 427 const ScDPGroupItem* ScDPGroupDimension::GetGroupByIndex( size_t nIndex ) const
 428 {
 429     if (nIndex >= aItems.size())
 430         return NULL;
 431
 432     return &aItems[nIndex];
 433 }
 434
 435 void ScDPGroupDimension::DisposeData()
 436 {
 437     maMemberEntries.clear();
 438 }
 439
 440 void ScDPGroupDimension::SetDateDimension()
 441 {
 442     mbDateDimension = true;
 443 }
 444
 445 bool ScDPGroupDimension::IsDateDimension() const
 446 {
 447     return mbDateDimension;
 448 }
 449
 450 // -----------------------------------------------------------------------
 451
 452 ScDPNumGroupDimension::ScDPNumGroupDimension() : mbDateDimension(false) {}
 453
 454 ScDPNumGroupDimension::ScDPNumGroupDimension( const ScDPNumGroupInfo& rInfo ) :
 455     aGroupInfo(rInfo), mbDateDimension(false) {}
 456
 457 ScDPNumGroupDimension::ScDPNumGroupDimension( const ScDPNumGroupDimension& rOther ) :
 458     aGroupInfo(rOther.aGroupInfo), mbDateDimension(rOther.mbDateDimension) {}
 459
 460 ScDPNumGroupDimension& ScDPNumGroupDimension::operator=( const ScDPNumGroupDimension& rOther )
 461 {
 462     aGroupInfo = rOther.aGroupInfo;
 463     mbDateDimension = rOther.mbDateDimension;
 464     return *this;
 465 }
 466
 467 void ScDPNumGroupDimension::DisposeData()
 468 {
 469     aGroupInfo = ScDPNumGroupInfo();
 470     maMemberEntries.clear();
 471 }
 472
 473 bool ScDPNumGroupDimension::IsDateDimension() const
 474 {
 475     return mbDateDimension;
 476 }
 477
 478 ScDPNumGroupDimension::~ScDPNumGroupDimension()
 479 {
 480 }
 481
 482 void ScDPNumGroupDimension::SetDateDimension()
 483 {
 484     aGroupInfo.mbEnable = true;   //! or query both?
 485     mbDateDimension = true;
 486 }
 487
 488 const std::vector<SCROW>& ScDPNumGroupDimension::GetNumEntries(
 489     SCCOL nSourceDim, const ScDPCache* pCache) const
 490 {
 491     if (!maMemberEntries.empty())
 492         return maMemberEntries;
 493
 494     pCache->GetGroupDimMemberIds(nSourceDim, maMemberEntries);
 495     return maMemberEntries;
 496 }
 497
 498 ScDPGroupTableData::ScDPGroupTableData( const shared_ptr<ScDPTableData>& pSource, ScDocument* pDocument ) :
 499     ScDPTableData(pDocument),
 500     pSourceData( pSource ),
 501     pDoc( pDocument )
 502 {
 503     OSL_ENSURE( pSource, "ScDPGroupTableData: pSource can't be NULL" );
 504
 505     CreateCacheTable();
 506     nSourceCount = pSource->GetColumnCount();               // real columns, excluding data layout
 507     pNumGroups = new ScDPNumGroupDimension[nSourceCount];
 508 }
 509
 510 ScDPGroupTableData::~ScDPGroupTableData()
 511 {
 512     delete[] pNumGroups;
 513 }
 514
 515 boost::shared_ptr<ScDPTableData> ScDPGroupTableData::GetSourceTableData()
 516 {
 517     return pSourceData;
 518 }
 519
 520 void ScDPGroupTableData::AddGroupDimension( const ScDPGroupDimension& rGroup )
 521 {
 522     ScDPGroupDimension aNewGroup( rGroup );
 523     aNewGroup.SetGroupDim( GetColumnCount() );      // new dimension will be at the end
 524     aGroups.push_back( aNewGroup );
 525     aGroupNames.insert(aNewGroup.GetName());
 526 }
 527
 528 void ScDPGroupTableData::SetNumGroupDimension( long nIndex, const ScDPNumGroupDimension& rGroup )
 529 {
 530     if ( nIndex < nSourceCount )
 531     {
 532         pNumGroups[nIndex] = rGroup;
 533
 534         // automatic minimum / maximum is handled in GetNumEntries
 535     }
 536 }
 537
 538 long ScDPGroupTableData::GetDimensionIndex( const OUString& rName )
 539 {
 540     for (long i = 0; i < nSourceCount; ++i)                         // nSourceCount excludes data layout
 541         if (pSourceData->getDimensionName(i).equals(rName))        //! ignore case?
 542             return i;
 543     return -1;  // none
 544 }
 545
 546 long ScDPGroupTableData::GetColumnCount()
 547 {
 548     return nSourceCount + aGroups.size();
 549 }
 550
 551 bool ScDPGroupTableData::IsNumGroupDimension( long nDimension ) const
 552 {
 553     return ( nDimension < nSourceCount && pNumGroups[nDimension].GetInfo().mbEnable );
 554 }
 555
 556 void ScDPGroupTableData::GetNumGroupInfo(long nDimension, ScDPNumGroupInfo& rInfo)
 557 {
 558     if ( nDimension < nSourceCount )
 559         rInfo = pNumGroups[nDimension].GetInfo();
 560 }
 561 long  ScDPGroupTableData::GetMembersCount( long nDim )
 562 {
 563     const std::vector< SCROW >&  members = GetColumnEntries( nDim );
 564     return members.size();
 565 }
 566 const std::vector< SCROW >& ScDPGroupTableData::GetColumnEntries( long  nColumn )
 567 {
 568     if ( nColumn >= nSourceCount )
 569     {
 570         if ( getIsDataLayoutDimension( nColumn) )     // data layout dimension?
 571             nColumn = nSourceCount;                         // index of data layout in source data
 572         else
 573         {
 574             const ScDPGroupDimension& rGroupDim = aGroups[nColumn - nSourceCount];
 575             return rGroupDim.GetColumnEntries( GetCacheTable() );
 576         }
 577     }
 578
 579     if ( IsNumGroupDimension( nColumn ) )
 580     {
 581         // dimension number is unchanged for numerical groups
 582         return pNumGroups[nColumn].GetNumEntries(
 583             static_cast<SCCOL>(nColumn), GetCacheTable().getCache());
 584     }
 585
 586     return pSourceData->GetColumnEntries( nColumn );
 587 }
 588
 589 const ScDPItemData* ScDPGroupTableData::GetMemberById( long nDim, long nId )
 590 {
 591     return pSourceData->GetMemberById( nDim, nId );
 592 }
 593
 594 OUString ScDPGroupTableData::getDimensionName(long nColumn)
 595 {
 596     if ( nColumn >= nSourceCount )
 597     {
 598         if ( nColumn == sal::static_int_cast<long>( nSourceCount + aGroups.size() ) )     // data layout dimension?
 599             nColumn = nSourceCount;                         // index of data layout in source data
 600         else
 601             return aGroups[nColumn - nSourceCount].GetName();
 602     }
 603
 604     return pSourceData->getDimensionName( nColumn );
 605 }
 606
 607 sal_Bool ScDPGroupTableData::getIsDataLayoutDimension(long nColumn)
 608 {
 609     // position of data layout dimension is moved from source data
 610     return ( nColumn == sal::static_int_cast<long>( nSourceCount + aGroups.size() ) );    // data layout dimension?
 611 }
 612
 613 sal_Bool ScDPGroupTableData::IsDateDimension(long nDim)
 614 {
 615     if ( nDim >= nSourceCount )
 616     {
 617         if ( nDim == sal::static_int_cast<long>( nSourceCount + aGroups.size() ) )        // data layout dimension?
 618             nDim = nSourceCount;                            // index of data layout in source data
 619         else
 620             nDim = aGroups[nDim - nSourceCount].GetSourceDim();  // look at original dimension
 621     }
 622
 623     return pSourceData->IsDateDimension( nDim );
 624 }
 625
 626 sal_uLong ScDPGroupTableData::GetNumberFormat(long nDim)
 627 {
 628     if ( nDim >= nSourceCount )
 629     {
 630         if ( nDim == sal::static_int_cast<long>( nSourceCount + aGroups.size() ) )        // data layout dimension?
 631             nDim = nSourceCount;                            // index of data layout in source data
 632         else
 633             nDim = aGroups[nDim - nSourceCount].GetSourceDim();  // look at original dimension
 634     }
 635
 636     return pSourceData->GetNumberFormat( nDim );
 637 }
 638
 639 void ScDPGroupTableData::DisposeData()
 640 {
 641     for ( ScDPGroupDimensionVec::iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 642         aIter->DisposeData();
 643
 644     for ( long i=0; i<nSourceCount; i++ )
 645         pNumGroups[i].DisposeData();
 646
 647     pSourceData->DisposeData();
 648 }
 649
 650 void ScDPGroupTableData::SetEmptyFlags( sal_Bool bIgnoreEmptyRows, sal_Bool bRepeatIfEmpty )
 651 {
 652     pSourceData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty );
 653 }
 654
 655 bool ScDPGroupTableData::IsRepeatIfEmpty()
 656 {
 657     return pSourceData->IsRepeatIfEmpty();
 658 }
 659
 660 void ScDPGroupTableData::CreateCacheTable()
 661 {
 662     pSourceData->CreateCacheTable();
 663 }
 664
 665 namespace {
 666
 667 class FindCaseInsensitive : std::unary_function<ScDPItemData, bool>
 668 {
 669     ScDPItemData maValue;
 670 public:
 671     FindCaseInsensitive(const ScDPItemData& rVal) : maValue(rVal) {}
 672
 673     bool operator() (const ScDPItemData& rItem) const
 674     {
 675         return maValue.IsCaseInsEqual(rItem);
 676     }
 677 };
 678
 679 }
 680
 681 void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPFilteredCache::Criterion>& rCriteria)
 682 {
 683     // Build dimension ID to object map for group dimensions.
 684     typedef boost::unordered_map<long, const ScDPGroupDimension*> GroupFieldMapType;
 685     GroupFieldMapType aGroupFieldIds;
 686     {
 687         ScDPGroupDimensionVec::const_iterator itr = aGroups.begin(), itrEnd = aGroups.end();
 688         for (; itr != itrEnd; ++itr)
 689         {
 690             aGroupFieldIds.insert(
 691                 GroupFieldMapType::value_type(itr->GetGroupDim(), &(*itr)));
 692         }
 693     }
 694
 695     vector<ScDPFilteredCache::Criterion> aNewCriteria;
 696     aNewCriteria.reserve(rCriteria.size() + aGroups.size());
 697
 698     // Go through all the filtered field names and process them appropriately.
 699
 700     const ScDPCache* pCache = GetCacheTable().getCache();
 701     vector<ScDPFilteredCache::Criterion>::const_iterator itrEnd = rCriteria.end();
 702     GroupFieldMapType::const_iterator itrGrpEnd = aGroupFieldIds.end();
 703     for (vector<ScDPFilteredCache::Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
 704     {
 705         std::vector<ScDPItemData> aMatchValues = itr->mpFilter->getMatchValues();
 706
 707         GroupFieldMapType::const_iterator itrGrp = aGroupFieldIds.find(itr->mnFieldIndex);
 708         if (itrGrp == itrGrpEnd)
 709         {
 710             if (IsNumGroupDimension(itr->mnFieldIndex))
 711             {
 712                 // internal number group field
 713                 const ScDPNumGroupInfo* pNumInfo = pCache->GetNumGroupInfo(itr->mnFieldIndex);
 714                 if (!pNumInfo)
 715                     // Number group dimension without num info?  Something is wrong...
 716                     continue;
 717
 718                 ScDPFilteredCache::Criterion aCri;
 719                 aCri.mnFieldIndex = itr->mnFieldIndex;
 720                 const ScDPNumGroupDimension& rNumGrpDim = pNumGroups[itr->mnFieldIndex];
 721
 722                 if (rNumGrpDim.IsDateDimension())
 723                 {
 724                     // grouped by dates.
 725                     aCri.mpFilter.reset(
 726                         new ScDPGroupDateFilter(
 727                             aMatchValues, *pDoc->GetFormatTable()->GetNullDate(), *pNumInfo));
 728                 }
 729                 else
 730                 {
 731                     // This dimension is grouped by numeric ranges.
 732                     aCri.mpFilter.reset(
 733                         new ScDPGroupNumFilter(aMatchValues, *pNumInfo));
 734                 }
 735
 736                 aNewCriteria.push_back(aCri);
 737             }
 738             else
 739             {
 740                 // This is a regular source field.
 741                 aNewCriteria.push_back(*itr);
 742             }
 743         }
 744         else
 745         {
 746             // This is an ordinary group field or external number group field.
 747
 748             const ScDPGroupDimension* pGrpDim = itrGrp->second;
 749             long nSrcDim = pGrpDim->GetSourceDim();
 750             long nGrpDim = pGrpDim->GetGroupDim();
 751             const ScDPNumGroupInfo* pNumInfo = pCache->GetNumGroupInfo(nGrpDim);
 752
 753             if (pGrpDim->IsDateDimension() && pNumInfo)
 754             {
 755                 // external number group
 756                 ScDPFilteredCache::Criterion aCri;
 757                 aCri.mnFieldIndex = nSrcDim;  // use the source dimension, not the group dimension.
 758                 aCri.mpFilter.reset(
 759                     new ScDPGroupDateFilter(
 760                         aMatchValues, *pDoc->GetFormatTable()->GetNullDate(), *pNumInfo));
 761
 762                 aNewCriteria.push_back(aCri);
 763             }
 764             else
 765             {
 766                 // normal group
 767
 768                 ScDPFilteredCache::Criterion aCri;
 769                 aCri.mnFieldIndex = nSrcDim;
 770                 aCri.mpFilter.reset(new ScDPFilteredCache::GroupFilter());
 771                 ScDPFilteredCache::GroupFilter* pGrpFilter =
 772                     static_cast<ScDPFilteredCache::GroupFilter*>(aCri.mpFilter.get());
 773
 774                 size_t nGroupItemCount = pGrpDim->GetItemCount();
 775                 for (size_t i = 0; i < nGroupItemCount; ++i)
 776                 {
 777                     const ScDPGroupItem* pGrpItem = pGrpDim->GetGroupByIndex(i);
 778                     if (!pGrpItem)
 779                         continue;
 780
 781                     // Make sure this group name equals one of the match values.
 782                     std::vector<ScDPItemData>::iterator it =
 783                         std::find_if(
 784                             aMatchValues.begin(), aMatchValues.end(), FindCaseInsensitive(pGrpItem->GetName()));
 785
 786                     if (it == aMatchValues.end())
 787                         continue;
 788
 789                     pGrpItem->FillGroupFilter(*pGrpFilter);
 790                 }
 791
 792                 aNewCriteria.push_back(aCri);
 793             }
 794         }
 795     }
 796     rCriteria.swap(aNewCriteria);
 797 }
 798
 799 void ScDPGroupTableData::FilterCacheTable(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
 800 {
 801     vector<ScDPFilteredCache::Criterion> aNewCriteria(rCriteria);
 802     ModifyFilterCriteria(aNewCriteria);
 803     pSourceData->FilterCacheTable(aNewCriteria, rCatDims);
 804 }
 805
 806 void ScDPGroupTableData::GetDrillDownData(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
 807 {
 808     vector<ScDPFilteredCache::Criterion> aNewCriteria(rCriteria);
 809     ModifyFilterCriteria(aNewCriteria);
 810     pSourceData->GetDrillDownData(aNewCriteria, rCatDims, rData);
 811 }
 812
 813 void ScDPGroupTableData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
 814 {
 815     // #i111435# Inside FillRowDataFromCacheTable/GetItemData, virtual methods
 816     // getIsDataLayoutDimension and GetSourceDim are used, so it has to be called
 817     // with original rInfo, containing dimension indexes of the grouped data.
 818
 819     const ScDPFilteredCache& rCacheTable = pSourceData->GetCacheTable();
 820     sal_Int32 nRowSize = rCacheTable.getRowSize();
 821     for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
 822     {
 823         sal_Int32 nLastRow;
 824         if (!rCacheTable.isRowActive(nRow, &nLastRow))
 825         {
 826             nRow = nLastRow;
 827             continue;
 828         }
 829
 830         CalcRowData aData;
 831         FillRowDataFromCacheTable(nRow, rCacheTable, rInfo, aData);
 832
 833         if ( !rInfo.aColLevelDims.empty() )
 834             FillGroupValues(aData.aColData, rInfo.aColLevelDims);
 835         if ( !rInfo.aRowLevelDims.empty() )
 836             FillGroupValues(aData.aRowData, rInfo.aRowLevelDims);
 837         if ( !rInfo.aPageDims.empty() )
 838             FillGroupValues(aData.aPageData, rInfo.aPageDims);
 839
 840         ProcessRowData(rInfo, aData, bAutoShow);
 841     }
 842 }
 843
 844 const ScDPFilteredCache& ScDPGroupTableData::GetCacheTable() const
 845 {
 846     return pSourceData->GetCacheTable();
 847 }
 848
 849 void ScDPGroupTableData::ReloadCacheTable()
 850 {
 851     pSourceData->ReloadCacheTable();
 852 }
 853
 854 void ScDPGroupTableData::FillGroupValues(vector<SCROW>& rItems, const vector<long>& rDims)
 855 {
 856     long nGroupedColumns = aGroups.size();
 857
 858     const ScDPCache* pCache = GetCacheTable().getCache();
 859     vector<long>::const_iterator it = rDims.begin(), itEnd = rDims.end();
 860     for (size_t i = 0; it != itEnd; ++it, ++i)
 861     {
 862         long nColumn = *it;
 863         bool bDateDim = false;
 864
 865         long nSourceDim = nColumn;
 866         if ( nColumn >= nSourceCount && nColumn < nSourceCount + nGroupedColumns )
 867         {
 868             const ScDPGroupDimension& rGroupDim = aGroups[nColumn - nSourceCount];
 869             nSourceDim= rGroupDim.GetSourceDim();
 870             bDateDim = rGroupDim.IsDateDimension();
 871             if (!bDateDim)                         // date is handled below
 872             {
 873                 const ScDPItemData& rItem = *GetMemberById(nSourceDim, rItems[i]);
 874                 const ScDPGroupItem* pGroupItem = rGroupDim.GetGroupForData(rItem);
 875                 if (pGroupItem)
 876                 {
 877                     rItems[i] =
 878                         pCache->GetIdByItemData(nColumn, pGroupItem->GetName());
 879                 }
 880                 else
 881                     rItems[i] = pCache->GetIdByItemData(nColumn, rItem);
 882             }
 883         }
 884         else if ( IsNumGroupDimension( nColumn ) )
 885         {
 886             bDateDim = pNumGroups[nColumn].IsDateDimension();
 887             if (!bDateDim)                         // date is handled below
 888             {
 889                 const ScDPItemData* pData = pCache->GetItemDataById(nSourceDim, rItems[i]);
 890                 if (pData->GetType() == ScDPItemData::Value)
 891                 {
 892                     ScDPNumGroupInfo aNumInfo;
 893                     GetNumGroupInfo(nColumn, aNumInfo);
 894                     double fGroupValue = ScDPUtil::getNumGroupStartValue(pData->GetValue(), aNumInfo);
 895                     ScDPItemData aItemData;
 896                     aItemData.SetRangeStart(fGroupValue);
 897                     rItems[i] = pCache->GetIdByItemData(nSourceDim, aItemData);
 898                 }
 899                 // else (textual) keep original value
 900             }
 901         }
 902
 903         const ScDPNumGroupInfo* pNumInfo = pCache->GetNumGroupInfo(nColumn);
 904
 905         if (bDateDim && pNumInfo)
 906         {
 907             // This is a date group dimension.
 908             sal_Int32 nDatePart = pCache->GetGroupType(nColumn);
 909             const ScDPItemData* pData = pCache->GetItemDataById(nSourceDim, rItems[i]);
 910             if (pData->GetType() == ScDPItemData::Value)
 911             {
 912                 SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
 913                 sal_Int32 nPartValue = ScDPUtil::getDatePartValue(
 914                     pData->GetValue(), *pNumInfo, nDatePart, pFormatter);
 915
 916                 ScDPItemData aItem(nDatePart, nPartValue);
 917                 rItems[i] = pCache->GetIdByItemData(nColumn, aItem);
 918             }
 919         }
 920     }
 921 }
 922
 923 sal_Bool ScDPGroupTableData::IsBaseForGroup(long nDim) const
 924 {
 925     for ( ScDPGroupDimensionVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 926     {
 927         const ScDPGroupDimension& rDim = *aIter;
 928         if ( rDim.GetSourceDim() == nDim )
 929             return sal_True;
 930     }
 931
 932     return false;
 933 }
 934
 935 long ScDPGroupTableData::GetGroupBase(long nGroupDim) const
 936 {
 937     for ( ScDPGroupDimensionVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 938     {
 939         const ScDPGroupDimension& rDim = *aIter;
 940         if ( rDim.GetGroupDim() == nGroupDim )
 941             return rDim.GetSourceDim();
 942     }
 943
 944     return -1;      // none
 945 }
 946
 947 sal_Bool ScDPGroupTableData::IsNumOrDateGroup(long nDimension) const
 948 {
 949     // Virtual method from ScDPTableData, used in result data to force text labels.
 950
 951     if ( nDimension < nSourceCount )
 952     {
 953         return pNumGroups[nDimension].GetInfo().mbEnable ||
 954                pNumGroups[nDimension].IsDateDimension();
 955     }
 956
 957     for ( ScDPGroupDimensionVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 958     {
 959         const ScDPGroupDimension& rDim = *aIter;
 960         if ( rDim.GetGroupDim() == nDimension )
 961             return rDim.IsDateDimension();
 962     }
 963
 964     return false;
 965 }
 966
 967 sal_Bool ScDPGroupTableData::IsInGroup( const ScDPItemData& rGroupData, long nGroupIndex,
 968                                     const ScDPItemData& rBaseData, long nBaseIndex ) const
 969 {
 970     for ( ScDPGroupDimensionVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 971     {
 972         const ScDPGroupDimension& rDim = *aIter;
 973         if ( rDim.GetGroupDim() == nGroupIndex && rDim.GetSourceDim() == nBaseIndex )
 974         {
 975             if (rDim.IsDateDimension())
 976             {
 977                 return isDateInGroup(rGroupData, rBaseData);
 978             }
 979             else
 980             {
 981                 // If the item is in a group, only that group is valid.
 982                 // If the item is not in any group, its own name is valid.
 983
 984                 const ScDPGroupItem* pGroup = rDim.GetGroupForData( rBaseData );
 985                 return pGroup ? pGroup->GetName().IsCaseInsEqual( rGroupData ) :
 986                                 rGroupData.IsCaseInsEqual( rBaseData );
 987             }
 988         }
 989     }
 990
 991     OSL_FAIL("IsInGroup: no group dimension found");
 992     return true;
 993 }
 994
 995 sal_Bool ScDPGroupTableData::HasCommonElement( const ScDPItemData& rFirstData, long nFirstIndex,
 996                                          const ScDPItemData& rSecondData, long nSecondIndex ) const
 997 {
 998     const ScDPGroupDimension* pFirstDim = NULL;
 999     const ScDPGroupDimension* pSecondDim = NULL;
1000     for ( ScDPGroupDimensionVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
1001     {
1002         const ScDPGroupDimension* pDim = &(*aIter);
1003         if ( pDim->GetGroupDim() == nFirstIndex )
1004             pFirstDim = pDim;
1005         else if ( pDim->GetGroupDim() == nSecondIndex )
1006             pSecondDim = pDim;
1007     }
1008     if ( pFirstDim && pSecondDim )
1009     {
1010         bool bFirstDate = pFirstDim->IsDateDimension();
1011         bool bSecondDate = pSecondDim->IsDateDimension();
1012         if (bFirstDate || bSecondDate)
1013         {
1014             // If one is a date group dimension, the other one must be, too.
1015             if (!bFirstDate || !bSecondDate)
1016             {
1017                 OSL_FAIL( "mix of date and non-date groups" );
1018                 return true;
1019             }
1020
1021             return isDateInGroup(rFirstData, rSecondData);
1022         }
1023
1024         const ScDPGroupItem* pFirstItem = pFirstDim->GetGroupForName( rFirstData );
1025         const ScDPGroupItem* pSecondItem = pSecondDim->GetGroupForName( rSecondData );
1026         if ( pFirstItem && pSecondItem )
1027         {
1028             // two existing groups -> sal_True if they have a common element
1029             return pFirstItem->HasCommonElement( *pSecondItem );
1030         }
1031         else if ( pFirstItem )
1032         {
1033             // "automatic" group contains only its own name
1034             return pFirstItem->HasElement( rSecondData );
1035         }
1036         else if ( pSecondItem )
1037         {
1038             // "automatic" group contains only its own name
1039             return pSecondItem->HasElement( rFirstData );
1040         }
1041         else
1042         {
1043             // no groups -> sal_True if equal
1044             return rFirstData.IsCaseInsEqual( rSecondData );
1045         }
1046     }
1047
1048     OSL_FAIL("HasCommonElement: no group dimension found");
1049     return true;
1050 }
1051
1052 long ScDPGroupTableData::GetSourceDim( long nDim )
1053 {
1054     if ( getIsDataLayoutDimension( nDim ) )
1055         return nSourceCount;
1056     if (  nDim >= nSourceCount && nDim < nSourceCount +(long) aGroups.size()  )
1057     {
1058          const ScDPGroupDimension& rGroupDim = aGroups[nDim - nSourceCount];
1059             return  rGroupDim.GetSourceDim();
1060     }
1061     return nDim;
1062 }
1063
1064 long ScDPGroupTableData::Compare(long nDim, long nDataId1, long nDataId2)
1065 {
1066     if ( getIsDataLayoutDimension(nDim) )
1067         return 0;
1068     return ScDPItemData::Compare( *GetMemberById(nDim,  nDataId1),*GetMemberById(nDim,  nDataId2) );
1069 }
1070
1071 #if DEBUG_PIVOT_TABLE
1072 using std::cout;
1073 using std::endl;
1074
1075 void ScDPGroupTableData::Dump() const
1076 {
1077     cout << "--- ScDPGroupTableData" << endl;
1078     for (long i = 0; i < nSourceCount; ++i)
1079     {
1080         cout << "* dimension: " << i << endl;
1081         const ScDPNumGroupDimension& rGrp = pNumGroups[i];
1082         rGrp.GetInfo().Dump();
1083     }
1084     cout << "---" << endl;
1085 }
1086 #endif
1087
1088 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */