sc/source/core/data/dpdimsave.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 "dpdimsave.hxx"
  21 #include "dpgroup.hxx"
  22 #include "dpobject.hxx"
  23 #include "dputil.hxx"
  24 #include "document.hxx"
  25
  26 #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
  27
  28 #include <svl/zforlist.hxx>
  29 #include <rtl/math.hxx>
  30 #include <algorithm>
  31
  32 #include "global.hxx"
  33 #include "scresid.hxx"
  34 #include "globstr.hrc"
  35
  36 using namespace com::sun::star;
  37
  38 ScDPSaveGroupItem::ScDPSaveGroupItem( const OUString& rName ) :
  39     aGroupName(rName) {}
  40
  41 ScDPSaveGroupItem::~ScDPSaveGroupItem() {}
  42
  43 void ScDPSaveGroupItem::AddElement( const OUString& rName )
  44 {
  45     aElements.push_back(rName);
  46 }
  47
  48 void ScDPSaveGroupItem::AddElementsFromGroup( const ScDPSaveGroupItem& rGroup )
  49 {
  50     // add all elements of the other group (used for nested grouping)
  51
  52     for ( std::vector<OUString>::const_iterator aIter(rGroup.aElements.begin());
  53                                 aIter != rGroup.aElements.end(); ++aIter )
  54         aElements.push_back( *aIter );
  55 }
  56
  57 bool ScDPSaveGroupItem::RemoveElement( const OUString& rName )
  58 {
  59     for (std::vector<OUString>::iterator aIter = aElements.begin(); aIter != aElements.end(); ++aIter)
  60         if (*aIter == rName)          //TODO: ignore case
  61         {
  62             aElements.erase(aIter);   // found -> remove
  63             return true;                // don't have to look further
  64         }
  65
  66     return false;   // not found
  67 }
  68
  69 bool ScDPSaveGroupItem::IsEmpty() const
  70 {
  71     return aElements.empty();
  72 }
  73
  74 size_t ScDPSaveGroupItem::GetElementCount() const
  75 {
  76     return aElements.size();
  77 }
  78
  79 const OUString* ScDPSaveGroupItem::GetElementByIndex(size_t nIndex) const
  80 {
  81     return (nIndex < aElements.size()) ? &aElements[ nIndex ] : 0;
  82 }
  83
  84 void ScDPSaveGroupItem::Rename( const OUString& rNewName )
  85 {
  86     aGroupName = rNewName;
  87 }
  88
  89 void ScDPSaveGroupItem::RemoveElementsFromGroups( ScDPSaveGroupDimension& rDimension ) const
  90 {
  91     // remove this group's elements from their groups in rDimension
  92     // (rDimension must be a different dimension from the one which contains this)
  93
  94     for ( std::vector<OUString>::const_iterator aIter(aElements.begin()); aIter != aElements.end(); ++aIter )
  95         rDimension.RemoveFromGroups( *aIter );
  96 }
  97
  98 void ScDPSaveGroupItem::ConvertElementsToItems(SvNumberFormatter* pFormatter) const
  99 {
 100     maItems.reserve(aElements.size());
 101     std::vector<OUString>::const_iterator it = aElements.begin(), itEnd = aElements.end();
 102     for (; it != itEnd; ++it)
 103     {
 104         sal_uInt32 nFormat = 0;
 105         double fValue;
 106         ScDPItemData aData;
 107         if (pFormatter->IsNumberFormat(*it, nFormat, fValue))
 108             aData.SetValue(fValue);
 109         else
 110             aData.SetString(*it);
 111
 112         maItems.push_back(aData);
 113     }
 114 }
 115
 116 bool ScDPSaveGroupItem::HasInGroup(const ScDPItemData& rItem) const
 117 {
 118     return std::find(maItems.begin(), maItems.end(), rItem) != maItems.end();
 119 }
 120
 121 void ScDPSaveGroupItem::AddToData(ScDPGroupDimension& rDataDim) const
 122 {
 123     ScDPGroupItem aGroup(aGroupName);
 124     std::vector<ScDPItemData>::const_iterator it = maItems.begin(), itEnd = maItems.end();
 125     for (; it != itEnd; ++it)
 126         aGroup.AddElement(*it);
 127
 128     rDataDim.AddItem(aGroup);
 129 }
 130
 131 ScDPSaveGroupDimension::ScDPSaveGroupDimension( const OUString& rSource, const OUString& rName ) :
 132     aSourceDim( rSource ),
 133     aGroupDimName( rName ),
 134     nDatePart( 0 )
 135 {
 136 }
 137
 138 ScDPSaveGroupDimension::ScDPSaveGroupDimension( const OUString& rSource, const OUString& rName, const ScDPNumGroupInfo& rDateInfo, sal_Int32 nPart ) :
 139     aSourceDim( rSource ),
 140     aGroupDimName( rName ),
 141     aDateInfo( rDateInfo ),
 142     nDatePart( nPart )
 143 {
 144 }
 145
 146 ScDPSaveGroupDimension::~ScDPSaveGroupDimension()
 147 {
 148 }
 149
 150 void ScDPSaveGroupDimension::SetDateInfo( const ScDPNumGroupInfo& rInfo, sal_Int32 nPart )
 151 {
 152     aDateInfo = rInfo;
 153     nDatePart = nPart;
 154 }
 155
 156 void ScDPSaveGroupDimension::AddGroupItem( const ScDPSaveGroupItem& rItem )
 157 {
 158     aGroups.push_back( rItem );
 159 }
 160
 161 OUString ScDPSaveGroupDimension::CreateGroupName(const OUString& rPrefix)
 162 {
 163     // create a name for a new group, using "Group1", "Group2" etc. (translated prefix in rPrefix)
 164
 165     //TODO: look in all dimensions, to avoid clashes with automatic groups (=name of base element)?
 166     //TODO: (only dimensions for the same base)
 167
 168     sal_Int32 nAdd = 1;                                 // first try is "Group1"
 169     const sal_Int32 nMaxAdd = nAdd + aGroups.size();    // limit the loop
 170     while ( nAdd <= nMaxAdd )
 171     {
 172         OUString aGroupName = rPrefix + OUString::number( nAdd );
 173         bool bExists = false;
 174
 175         // look for existing groups
 176         for ( ScDPSaveGroupItemVec::const_iterator aIter(aGroups.begin());
 177                                     aIter != aGroups.end() && !bExists; ++aIter )
 178             if (aIter->GetGroupName().equals(aGroupName))         //TODO: ignore case
 179                 bExists = true;
 180
 181         if ( !bExists )
 182             return aGroupName;          // found a new name
 183
 184         ++nAdd;                         // continue with higher number
 185     }
 186
 187     OSL_FAIL("CreateGroupName: no valid name found");
 188     return OUString();
 189 }
 190
 191 const ScDPSaveGroupItem* ScDPSaveGroupDimension::GetNamedGroup( const OUString& rGroupName ) const
 192 {
 193     return const_cast< ScDPSaveGroupDimension* >( this )->GetNamedGroupAcc( rGroupName );
 194 }
 195
 196 ScDPSaveGroupItem* ScDPSaveGroupDimension::GetNamedGroupAcc( const OUString& rGroupName )
 197 {
 198     for (ScDPSaveGroupItemVec::iterator aIter = aGroups.begin(); aIter != aGroups.end(); ++aIter)
 199         if (aIter->GetGroupName().equals(rGroupName))         //TODO: ignore case
 200             return &*aIter;
 201
 202     return NULL;        // none found
 203 }
 204
 205 long ScDPSaveGroupDimension::GetGroupCount() const
 206 {
 207     return aGroups.size();
 208 }
 209
 210 const ScDPSaveGroupItem* ScDPSaveGroupDimension::GetGroupByIndex( long nIndex ) const
 211 {
 212     return const_cast< ScDPSaveGroupDimension* >( this )->GetGroupAccByIndex( nIndex );
 213 }
 214
 215 ScDPSaveGroupItem* ScDPSaveGroupDimension::GetGroupAccByIndex( long nIndex )
 216 {
 217     return &aGroups[nIndex];
 218 }
 219
 220 void ScDPSaveGroupDimension::RemoveFromGroups( const OUString& rItemName )
 221 {
 222     //  if the item is in any group, remove it from the group,
 223     //  also remove the group if it is empty afterwards
 224
 225     for ( ScDPSaveGroupItemVec::iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter )
 226         if ( aIter->RemoveElement( rItemName ) )
 227         {
 228             if ( aIter->IsEmpty() )         // removed last item from the group?
 229                 aGroups.erase( aIter );     // then remove the group
 230
 231             return;     // don't have to look further
 232         }
 233 }
 234
 235 void ScDPSaveGroupDimension::RemoveGroup(const OUString& rGroupName)
 236 {
 237     for (ScDPSaveGroupItemVec::iterator aIter = aGroups.begin(); aIter != aGroups.end(); ++aIter)
 238         if (aIter->GetGroupName().equals(rGroupName))          //TODO: ignore case
 239         {
 240             aGroups.erase( aIter );
 241             return;                     // don't have to look further
 242         }
 243 }
 244
 245 bool ScDPSaveGroupDimension::IsEmpty() const
 246 {
 247     return aGroups.empty();
 248 }
 249
 250 bool ScDPSaveGroupDimension::HasOnlyHidden(const ScDPUniqueStringSet& rVisible)
 251 {
 252     // check if there are only groups that don't appear in the list of visible names
 253
 254     bool bAllHidden = true;
 255     for (ScDPSaveGroupItemVec::const_iterator aIter = aGroups.begin(); aIter != aGroups.end() && bAllHidden; ++aIter)
 256     {
 257         if (rVisible.count(aIter->GetGroupName()) > 0)
 258             bAllHidden = false;
 259     }
 260     return bAllHidden;
 261 }
 262
 263 void ScDPSaveGroupDimension::Rename( const OUString& rNewName )
 264 {
 265     aGroupDimName = rNewName;
 266 }
 267
 268 bool ScDPSaveGroupDimension::IsInGroup(const ScDPItemData& rItem) const
 269 {
 270     ScDPSaveGroupItemVec::const_iterator it = aGroups.begin(), itEnd = aGroups.end();
 271     for (; it != itEnd; ++it)
 272     {
 273         if (it->HasInGroup(rItem))
 274             return true;
 275     }
 276     return false;
 277 }
 278
 279 namespace {
 280
 281 inline bool isInteger(double fValue)
 282 {
 283     return rtl::math::approxEqual(fValue, rtl::math::approxFloor(fValue));
 284 }
 285
 286 void fillDateGroupDimension(
 287     ScDPCache& rCache, ScDPNumGroupInfo& rDateInfo, long nSourceDim, long nGroupDim,
 288     sal_Int32 nDatePart, SvNumberFormatter* pFormatter)
 289 {
 290     // Auto min/max is only used for "Years" part, but the loop is always
 291     // needed.
 292     double fSourceMin = 0.0;
 293     double fSourceMax = 0.0;
 294     bool bFirst = true;
 295
 296     const ScDPCache::ItemsType& rItems = rCache.GetDimMemberValues(nSourceDim);
 297     ScDPCache::ItemsType::const_iterator it = rItems.begin(), itEnd = rItems.end();
 298     for (; it != itEnd; ++it)
 299     {
 300         const ScDPItemData& rItem = *it;
 301         if (rItem.GetType() != ScDPItemData::Value)
 302             continue;
 303
 304         double fVal = rItem.GetValue();
 305         if (bFirst)
 306         {
 307             fSourceMin = fSourceMax = fVal;
 308             bFirst = false;
 309         }
 310         else
 311         {
 312             if (fVal < fSourceMin)
 313                 fSourceMin = fVal;
 314             if ( fVal > fSourceMax )
 315                 fSourceMax = fVal;
 316         }
 317     }
 318
 319     // For the start/end values, use the same date rounding as in
 320     // ScDPNumGroupDimension::GetNumEntries (but not for the list of
 321     // available years).
 322     if (rDateInfo.mbAutoStart)
 323         rDateInfo.mfStart = rtl::math::approxFloor(fSourceMin);
 324     if (rDateInfo.mbAutoEnd)
 325         rDateInfo.mfEnd = rtl::math::approxFloor(fSourceMax) + 1;
 326
 327     //TODO: if not automatic, limit fSourceMin/fSourceMax for list of year values?
 328
 329     long nStart = 0, nEnd = 0; // end is inclusive
 330
 331     switch (nDatePart)
 332     {
 333         case sheet::DataPilotFieldGroupBy::YEARS:
 334             nStart = ScDPUtil::getDatePartValue(
 335                 fSourceMin, NULL, sheet::DataPilotFieldGroupBy::YEARS, pFormatter);
 336             nEnd = ScDPUtil::getDatePartValue(fSourceMax, NULL, sheet::DataPilotFieldGroupBy::YEARS, pFormatter);
 337             break;
 338         case sheet::DataPilotFieldGroupBy::QUARTERS: nStart = 1; nEnd = 4;   break;
 339         case sheet::DataPilotFieldGroupBy::MONTHS:   nStart = 1; nEnd = 12;  break;
 340         case sheet::DataPilotFieldGroupBy::DAYS:     nStart = 1; nEnd = 366; break;
 341         case sheet::DataPilotFieldGroupBy::HOURS:    nStart = 0; nEnd = 23;  break;
 342         case sheet::DataPilotFieldGroupBy::MINUTES:  nStart = 0; nEnd = 59;  break;
 343         case sheet::DataPilotFieldGroupBy::SECONDS:  nStart = 0; nEnd = 59;  break;
 344         default:
 345             OSL_FAIL("invalid date part");
 346     }
 347
 348     // Now, populate the group items in the cache.
 349     rCache.ResetGroupItems(nGroupDim, rDateInfo, nDatePart);
 350
 351     for (sal_Int32 nValue = nStart; nValue <= nEnd; ++nValue)
 352         rCache.SetGroupItem(nGroupDim, ScDPItemData(nDatePart, nValue));
 353
 354     // add first/last entry (min/max)
 355     rCache.SetGroupItem(nGroupDim, ScDPItemData(nDatePart, ScDPItemData::DateFirst));
 356     rCache.SetGroupItem(nGroupDim, ScDPItemData(nDatePart, ScDPItemData::DateLast));
 357 }
 358
 359 }
 360
 361 void ScDPSaveGroupDimension::AddToData( ScDPGroupTableData& rData ) const
 362 {
 363     long nSourceIndex = rData.GetDimensionIndex( aSourceDim );
 364     if ( nSourceIndex >= 0 )
 365     {
 366         ScDPGroupDimension aDim( nSourceIndex, aGroupDimName );
 367         if ( nDatePart )
 368         {
 369             // date grouping
 370
 371             aDim.SetDateDimension();
 372         }
 373         else
 374         {
 375             // normal (manual) grouping
 376
 377             for (ScDPSaveGroupItemVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); ++aIter)
 378                 aIter->AddToData(aDim);
 379         }
 380
 381         rData.AddGroupDimension( aDim );
 382     }
 383 }
 384
 385 void ScDPSaveGroupDimension::AddToCache(ScDPCache& rCache) const
 386 {
 387     long nSourceDim = rCache.GetDimensionIndex(aSourceDim);
 388     if (nSourceDim < 0)
 389         return;
 390
 391     long nDim = rCache.AppendGroupField();
 392     SvNumberFormatter* pFormatter = rCache.GetDoc()->GetFormatTable();
 393
 394     if (nDatePart)
 395     {
 396         fillDateGroupDimension(rCache, aDateInfo, nSourceDim, nDim, nDatePart, pFormatter);
 397         return;
 398     }
 399
 400     rCache.ResetGroupItems(nDim, aDateInfo, 0);
 401     {
 402         ScDPSaveGroupItemVec::const_iterator it = aGroups.begin(), itEnd = aGroups.end();
 403         for (; it != itEnd; ++it)
 404         {
 405             const ScDPSaveGroupItem& rGI = *it;
 406             rGI.ConvertElementsToItems(pFormatter);
 407             rCache.SetGroupItem(nDim, ScDPItemData(rGI.GetGroupName()));
 408         }
 409     }
 410
 411     const ScDPCache::ItemsType& rItems = rCache.GetDimMemberValues(nSourceDim);
 412     {
 413         ScDPCache::ItemsType::const_iterator it = rItems.begin(), itEnd = rItems.end();
 414         for (; it != itEnd; ++it)
 415         {
 416             const ScDPItemData& rItem = *it;
 417             if (!IsInGroup(rItem))
 418                 // Not in any group.  Add as its own group.
 419                 rCache.SetGroupItem(nDim, rItem);
 420         }
 421     }
 422 }
 423
 424 ScDPSaveNumGroupDimension::ScDPSaveNumGroupDimension( const OUString& rName, const ScDPNumGroupInfo& rInfo ) :
 425     aDimensionName( rName ),
 426     aGroupInfo( rInfo ),
 427     nDatePart( 0 )
 428 {
 429 }
 430
 431 ScDPSaveNumGroupDimension::ScDPSaveNumGroupDimension( const OUString& rName, const ScDPNumGroupInfo& rDateInfo, sal_Int32 nPart ) :
 432     aDimensionName( rName ),
 433     aDateInfo( rDateInfo ),
 434     nDatePart( nPart )
 435 {
 436 }
 437
 438 ScDPSaveNumGroupDimension::~ScDPSaveNumGroupDimension()
 439 {
 440 }
 441
 442 void ScDPSaveNumGroupDimension::AddToData( ScDPGroupTableData& rData ) const
 443 {
 444     long nSource = rData.GetDimensionIndex( aDimensionName );
 445     if ( nSource >= 0 )
 446     {
 447         ScDPNumGroupDimension aDim( aGroupInfo );           // aGroupInfo: value grouping
 448         if ( nDatePart )
 449             aDim.SetDateDimension();
 450
 451         rData.SetNumGroupDimension( nSource, aDim );
 452     }
 453 }
 454
 455 void ScDPSaveNumGroupDimension::AddToCache(ScDPCache& rCache) const
 456 {
 457     long nDim = rCache.GetDimensionIndex(aDimensionName);
 458     if (nDim < 0)
 459         return;
 460
 461     if (aDateInfo.mbEnable)
 462     {
 463         // Date grouping
 464         SvNumberFormatter* pFormatter = rCache.GetDoc()->GetFormatTable();
 465         fillDateGroupDimension(rCache, aDateInfo, nDim, nDim, nDatePart, pFormatter);
 466     }
 467     else if (aGroupInfo.mbEnable)
 468     {
 469         // Number-range grouping
 470
 471         // Look through the source entries for non-integer numbers, minimum
 472         // and maximum.
 473
 474         // non-integer GroupInfo values count, too
 475         aGroupInfo.mbIntegerOnly =
 476             (aGroupInfo.mbAutoStart || isInteger(aGroupInfo.mfStart)) &&
 477             (aGroupInfo.mbAutoEnd || isInteger(aGroupInfo.mfEnd)) &&
 478             isInteger(aGroupInfo.mfStep);
 479
 480         double fSourceMin = 0.0;
 481         double fSourceMax = 0.0;
 482         bool bFirst = true;
 483
 484         const ScDPCache::ItemsType& rItems = rCache.GetDimMemberValues(nDim);
 485         ScDPCache::ItemsType::const_iterator it = rItems.begin(), itEnd = rItems.end();
 486         for (; it != itEnd; ++it)
 487         {
 488             const ScDPItemData& rItem = *it;
 489             if (rItem.GetType() != ScDPItemData::Value)
 490                 continue;
 491
 492             double fValue = rItem.GetValue();
 493             if (bFirst)
 494             {
 495                 fSourceMin = fSourceMax = fValue;
 496                 bFirst = false;
 497                 continue;
 498             }
 499
 500             if (fValue < fSourceMin)
 501                 fSourceMin = fValue;
 502             if (fValue > fSourceMax)
 503                 fSourceMax = fValue;
 504
 505             if (aGroupInfo.mbIntegerOnly && !isInteger(fValue))
 506             {
 507                 // If any non-integer numbers are involved, the group labels
 508                 // are shown including their upper limit.
 509                 aGroupInfo.mbIntegerOnly = false;
 510             }
 511         }
 512
 513         if (aGroupInfo.mbDateValues)
 514         {
 515             // special handling for dates: always integer, round down limits
 516             aGroupInfo.mbIntegerOnly = true;
 517             fSourceMin = rtl::math::approxFloor(fSourceMin);
 518             fSourceMax = rtl::math::approxFloor(fSourceMax) + 1;
 519         }
 520
 521         if (aGroupInfo.mbAutoStart)
 522             aGroupInfo.mfStart = fSourceMin;
 523         if (aGroupInfo.mbAutoEnd)
 524             aGroupInfo.mfEnd = fSourceMax;
 525
 526         //TODO: limit number of entries?
 527
 528         long nLoopCount = 0;
 529         double fLoop = aGroupInfo.mfStart;
 530
 531         rCache.ResetGroupItems(nDim, aGroupInfo, 0);
 532
 533         // Use "less than" instead of "less or equal" for the loop - don't
 534         // create a group that consists only of the end value. Instead, the
 535         // end value is then included in the last group (last group is bigger
 536         // than the others). The first group has to be created nonetheless.
 537         // GetNumGroupForValue has corresponding logic.
 538
 539         bool bFirstGroup = true;
 540         while (bFirstGroup || (fLoop < aGroupInfo.mfEnd && !rtl::math::approxEqual(fLoop, aGroupInfo.mfEnd)))
 541         {
 542             ScDPItemData aItem;
 543             aItem.SetRangeStart(fLoop);
 544             rCache.SetGroupItem(nDim, aItem);
 545             ++nLoopCount;
 546             fLoop = aGroupInfo.mfStart + nLoopCount * aGroupInfo.mfStep;
 547             bFirstGroup = false;
 548
 549             // ScDPItemData values are compared with approxEqual
 550         }
 551
 552         ScDPItemData aItem;
 553         aItem.SetRangeFirst();
 554         rCache.SetGroupItem(nDim, aItem);
 555
 556         aItem.SetRangeLast();
 557         rCache.SetGroupItem(nDim, aItem);
 558     }
 559 }
 560
 561 void ScDPSaveNumGroupDimension::SetGroupInfo( const ScDPNumGroupInfo& rNew )
 562 {
 563     aGroupInfo = rNew;
 564 }
 565
 566 void ScDPSaveNumGroupDimension::SetDateInfo( const ScDPNumGroupInfo& rInfo, sal_Int32 nPart )
 567 {
 568     aDateInfo = rInfo;
 569     nDatePart = nPart;
 570 }
 571
 572 namespace {
 573
 574 struct ScDPSaveGroupDimNameFunc
 575 {
 576     OUString       maDimName;
 577     inline explicit     ScDPSaveGroupDimNameFunc( const OUString& rDimName ) : maDimName( rDimName ) {}
 578     inline bool         operator()( const ScDPSaveGroupDimension& rGroupDim ) const { return rGroupDim.GetGroupDimName() == maDimName; }
 579 };
 580
 581 struct ScDPSaveGroupSourceNameFunc
 582 {
 583     OUString       maSrcDimName;
 584     inline explicit     ScDPSaveGroupSourceNameFunc( const OUString& rSrcDimName ) : maSrcDimName( rSrcDimName ) {}
 585     inline bool         operator()( const ScDPSaveGroupDimension& rGroupDim ) const { return rGroupDim.GetSourceDimName() == maSrcDimName; }
 586 };
 587
 588 } // namespace
 589
 590 ScDPDimensionSaveData::ScDPDimensionSaveData()
 591 {
 592 }
 593
 594 ScDPDimensionSaveData::~ScDPDimensionSaveData()
 595 {
 596 }
 597
 598 bool ScDPDimensionSaveData::operator==( const ScDPDimensionSaveData& ) const
 599 {
 600     return false;
 601 }
 602
 603 void ScDPDimensionSaveData::AddGroupDimension( const ScDPSaveGroupDimension& rGroupDim )
 604 {
 605     OSL_ENSURE( ::std::none_of( maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupDimNameFunc( rGroupDim.GetGroupDimName() ) ),
 606         "ScDPDimensionSaveData::AddGroupDimension - group dimension exists already" );
 607     // ReplaceGroupDimension() adds new or replaces existing
 608     ReplaceGroupDimension( rGroupDim );
 609 }
 610
 611 void ScDPDimensionSaveData::ReplaceGroupDimension( const ScDPSaveGroupDimension& rGroupDim )
 612 {
 613     ScDPSaveGroupDimVec::iterator aIt = ::std::find_if(
 614         maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupDimNameFunc( rGroupDim.GetGroupDimName() ) );
 615     if( aIt == maGroupDims.end() )
 616         maGroupDims.push_back( rGroupDim );
 617     else
 618         *aIt = rGroupDim;
 619 }
 620
 621 void ScDPDimensionSaveData::RemoveGroupDimension( const OUString& rGroupDimName )
 622 {
 623     ScDPSaveGroupDimVec::iterator aIt = ::std::find_if(
 624         maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupDimNameFunc( rGroupDimName ) );
 625     if( aIt != maGroupDims.end() )
 626         maGroupDims.erase( aIt );
 627 }
 628
 629 void ScDPDimensionSaveData::AddNumGroupDimension( const ScDPSaveNumGroupDimension& rGroupDim )
 630 {
 631     OSL_ENSURE( maNumGroupDims.count( rGroupDim.GetDimensionName() ) == 0,
 632         "ScDPDimensionSaveData::AddNumGroupDimension - numeric group dimension exists already" );
 633     // ReplaceNumGroupDimension() adds new or replaces existing
 634     ReplaceNumGroupDimension( rGroupDim );
 635 }
 636
 637 void ScDPDimensionSaveData::ReplaceNumGroupDimension( const ScDPSaveNumGroupDimension& rGroupDim )
 638 {
 639     ScDPSaveNumGroupDimMap::iterator aIt = maNumGroupDims.find( rGroupDim.GetDimensionName() );
 640     if( aIt == maNumGroupDims.end() )
 641         maNumGroupDims.insert( ScDPSaveNumGroupDimMap::value_type( rGroupDim.GetDimensionName(), rGroupDim ) );
 642     else
 643         aIt->second = rGroupDim;
 644 }
 645
 646 void ScDPDimensionSaveData::RemoveNumGroupDimension( const OUString& rGroupDimName )
 647 {
 648     maNumGroupDims.erase( rGroupDimName );
 649 }
 650
 651 void ScDPDimensionSaveData::WriteToData( ScDPGroupTableData& rData ) const
 652 {
 653     //  rData is assumed to be empty
 654     //  AddToData also handles date grouping
 655
 656     for( ScDPSaveGroupDimVec::const_iterator aIt = maGroupDims.begin(), aEnd = maGroupDims.end(); aIt != aEnd; ++aIt )
 657         aIt->AddToData( rData );
 658
 659     for( ScDPSaveNumGroupDimMap::const_iterator aIt = maNumGroupDims.begin(), aEnd = maNumGroupDims.end(); aIt != aEnd; ++aIt )
 660         aIt->second.AddToData( rData );
 661 }
 662
 663 namespace {
 664
 665 class AddGroupDimToCache : std::unary_function<ScDPSaveGroupDimension, void>
 666 {
 667     ScDPCache& mrCache;
 668 public:
 669     AddGroupDimToCache(ScDPCache& rCache) : mrCache(rCache) {}
 670     void operator() (const ScDPSaveGroupDimension& rDim)
 671     {
 672         rDim.AddToCache(mrCache);
 673     }
 674 };
 675
 676 }
 677
 678 void ScDPDimensionSaveData::WriteToCache(ScDPCache& rCache) const
 679 {
 680     std::for_each(maGroupDims.begin(), maGroupDims.end(), AddGroupDimToCache(rCache));
 681     ScDPSaveNumGroupDimMap::const_iterator it = maNumGroupDims.begin(), itEnd = maNumGroupDims.end();
 682     for (; it != itEnd; ++it)
 683         it->second.AddToCache(rCache);
 684 }
 685
 686 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetGroupDimForBase( const OUString& rBaseDimName ) const
 687 {
 688     return const_cast< ScDPDimensionSaveData* >( this )->GetGroupDimAccForBase( rBaseDimName );
 689 }
 690
 691 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNamedGroupDim( const OUString& rGroupDimName ) const
 692 {
 693     return const_cast< ScDPDimensionSaveData* >( this )->GetNamedGroupDimAcc( rGroupDimName );
 694 }
 695
 696 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetFirstNamedGroupDim( const OUString& rBaseDimName ) const
 697 {
 698     return const_cast< ScDPDimensionSaveData* >( this )->GetFirstNamedGroupDimAcc( rBaseDimName );
 699 }
 700
 701 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNextNamedGroupDim( const OUString& rGroupDimName ) const
 702 {
 703     return const_cast< ScDPDimensionSaveData* >( this )->GetNextNamedGroupDimAcc( rGroupDimName );
 704 }
 705
 706 const ScDPSaveNumGroupDimension* ScDPDimensionSaveData::GetNumGroupDim( const OUString& rGroupDimName ) const
 707 {
 708     return const_cast< ScDPDimensionSaveData* >( this )->GetNumGroupDimAcc( rGroupDimName );
 709 }
 710
 711 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetGroupDimAccForBase( const OUString& rBaseDimName )
 712 {
 713     ScDPSaveGroupDimension* pGroupDim = GetFirstNamedGroupDimAcc( rBaseDimName );
 714     return pGroupDim ? pGroupDim : GetNextNamedGroupDimAcc( rBaseDimName );
 715 }
 716
 717 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNamedGroupDimAcc( const OUString& rGroupDimName )
 718 {
 719     ScDPSaveGroupDimVec::iterator aIt = ::std::find_if(
 720         maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupDimNameFunc( rGroupDimName ) );
 721     return (aIt == maGroupDims.end()) ? 0 : &*aIt;
 722 }
 723
 724 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetFirstNamedGroupDimAcc( const OUString& rBaseDimName )
 725 {
 726     ScDPSaveGroupDimVec::iterator aIt = ::std::find_if(
 727         maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupSourceNameFunc( rBaseDimName ) );
 728     return (aIt == maGroupDims.end()) ? 0 : &*aIt;
 729 }
 730
 731 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNextNamedGroupDimAcc( const OUString& rGroupDimName )
 732 {
 733     // find the group dimension with the passed name
 734     ScDPSaveGroupDimVec::iterator aIt = ::std::find_if(
 735         maGroupDims.begin(), maGroupDims.end(), ScDPSaveGroupDimNameFunc( rGroupDimName ) );
 736     // find next group dimension based on the same source dimension name
 737     if( aIt != maGroupDims.end() )
 738         aIt = ::std::find_if( aIt + 1, maGroupDims.end(), ScDPSaveGroupSourceNameFunc( aIt->GetSourceDimName() ) );
 739     return (aIt == maGroupDims.end()) ? 0 : &*aIt;
 740 }
 741
 742 ScDPSaveNumGroupDimension* ScDPDimensionSaveData::GetNumGroupDimAcc( const OUString& rGroupDimName )
 743 {
 744     ScDPSaveNumGroupDimMap::iterator aIt = maNumGroupDims.find( rGroupDimName );
 745     return (aIt == maNumGroupDims.end()) ? 0 : &aIt->second;
 746 }
 747
 748 bool ScDPDimensionSaveData::HasGroupDimensions() const
 749 {
 750     return !maGroupDims.empty() || !maNumGroupDims.empty();
 751 }
 752
 753 sal_Int32 ScDPDimensionSaveData::CollectDateParts( const OUString& rBaseDimName ) const
 754 {
 755     sal_Int32 nParts = 0;
 756     // start with part of numeric group
 757     if( const ScDPSaveNumGroupDimension* pNumDim = GetNumGroupDim( rBaseDimName ) )
 758         nParts |= pNumDim->GetDatePart();
 759     // collect parts from all matching group dimensions
 760     for( const ScDPSaveGroupDimension* pGroupDim = GetFirstNamedGroupDim( rBaseDimName ); pGroupDim; pGroupDim = GetNextNamedGroupDim( pGroupDim->GetGroupDimName() ) )
 761         nParts |= pGroupDim->GetDatePart();
 762
 763     return nParts;
 764 }
 765
 766 OUString ScDPDimensionSaveData::CreateGroupDimName(
 767     const OUString& rSourceName, const ScDPObject& rObject, bool bAllowSource,
 768     const std::vector<OUString>* pDeletedNames )
 769 {
 770     // create a name for the new dimension by appending a number to the original
 771     // dimension's name
 772
 773     bool bUseSource = bAllowSource;     // if set, try the unchanged original name first
 774
 775     sal_Int32 nAdd = 2;                 // first try is "Name2"
 776     const sal_Int32 nMaxAdd = 1000;     // limit the loop
 777     while ( nAdd <= nMaxAdd )
 778     {
 779         OUString aDimName( rSourceName );
 780         if ( !bUseSource )
 781             aDimName += OUString::number(nAdd);
 782         bool bExists = false;
 783
 784         // look for existing group dimensions
 785         for( ScDPSaveGroupDimVec::const_iterator aIt = maGroupDims.begin(), aEnd = maGroupDims.end(); (aIt != aEnd) && !bExists; ++aIt )
 786             if( aIt->GetGroupDimName() == aDimName )         //TODO: ignore case
 787                 bExists = true;
 788
 789         // look for base dimensions that happen to have that name
 790         if ( !bExists && rObject.IsDimNameInUse( aDimName ) )
 791         {
 792             if ( pDeletedNames &&
 793                  std::find( pDeletedNames->begin(), pDeletedNames->end(), aDimName ) != pDeletedNames->end() )
 794             {
 795                 // allow the name anyway if the name is in pDeletedNames
 796             }
 797             else
 798                 bExists = true;
 799         }
 800
 801         if ( !bExists )
 802             return aDimName;            // found a new name
 803
 804         if ( bUseSource )
 805             bUseSource = false;
 806         else
 807             ++nAdd;                     // continue with higher number
 808     }
 809     OSL_FAIL("CreateGroupDimName: no valid name found");
 810     return OUString();
 811 }
 812
 813 namespace
 814 {
 815     static const sal_uInt16 nDatePartIds[] =
 816     {
 817         STR_DPFIELD_GROUP_BY_SECONDS,
 818         STR_DPFIELD_GROUP_BY_MINUTES,
 819         STR_DPFIELD_GROUP_BY_HOURS,
 820         STR_DPFIELD_GROUP_BY_DAYS,
 821         STR_DPFIELD_GROUP_BY_MONTHS,
 822         STR_DPFIELD_GROUP_BY_QUARTERS,
 823         STR_DPFIELD_GROUP_BY_YEARS
 824     };
 825 }
 826
 827 OUString ScDPDimensionSaveData::CreateDateGroupDimName(
 828     sal_Int32 nDatePart, const ScDPObject& rObject, bool bAllowSource,
 829     const std::vector<OUString>* pDeletedNames )
 830 {
 831     using namespace ::com::sun::star::sheet::DataPilotFieldGroupBy;
 832     OUString aPartName;
 833     switch( nDatePart )
 834     {
 835         case SECONDS:  aPartName = ScGlobal::GetRscString( nDatePartIds[0] ); break;
 836         case MINUTES:  aPartName = ScGlobal::GetRscString( nDatePartIds[1] ); break;
 837         case HOURS:    aPartName = ScGlobal::GetRscString( nDatePartIds[2] ); break;
 838         case DAYS:     aPartName = ScGlobal::GetRscString( nDatePartIds[3] ); break;
 839         case MONTHS:   aPartName = ScGlobal::GetRscString( nDatePartIds[4] ); break;
 840         case QUARTERS: aPartName = ScGlobal::GetRscString( nDatePartIds[5] ); break;
 841         case YEARS:    aPartName = ScGlobal::GetRscString( nDatePartIds[6] ); break;
 842     }
 843     OSL_ENSURE(!aPartName.isEmpty(), "ScDPDimensionSaveData::CreateDateGroupDimName - invalid date part");
 844     return CreateGroupDimName( aPartName, rObject, bAllowSource, pDeletedNames );
 845 }
 846
 847 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */