LCOV - code coverage report
Current view: top level - sc/source/core/data - dpdimsave.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 398 0.0 %
Date: 2014-04-14 Functions: 0 78 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10