sc/source/core/data/dpdimsave.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: dpdimsave.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 // INCLUDE ---------------------------------------------------------------
  37
  38 #include "dpdimsave.hxx"
  39 #include "dpgroup.hxx"
  40 #include "dpobject.hxx"
  41 #include "document.hxx"
  42
  43 #include <svtools/zforlist.hxx>
  44 #include <tools/debug.hxx>
  45 #include <rtl/math.hxx>
  46 #include <algorithm>
  47
  48 // -----------------------------------------------------------------------
  49
  50 ScDPSaveGroupItem::ScDPSaveGroupItem( const String& rName ) :
  51     aGroupName( rName )
  52 {
  53 }
  54
  55 ScDPSaveGroupItem::ScDPSaveGroupItem( const ScDPSaveGroupItem& r ) :
  56     aGroupName( r.aGroupName ),
  57     aElements( r.aElements )
  58 {
  59 }
  60
  61 ScDPSaveGroupItem::~ScDPSaveGroupItem()
  62 {
  63 }
  64
  65 void ScDPSaveGroupItem::AddElement( const String& rName )
  66 {
  67     aElements.push_back( rName );
  68 }
  69
  70 void ScDPSaveGroupItem::AddElementsFromGroup( const ScDPSaveGroupItem& rGroup )
  71 {
  72     // add all elements of the other group (used for nested grouping)
  73
  74     for ( std::vector<String>::const_iterator aIter(rGroup.aElements.begin());
  75                                 aIter != rGroup.aElements.end(); aIter++ )
  76         aElements.push_back( *aIter );
  77 }
  78
  79 bool ScDPSaveGroupItem::RemoveElement( const String& rName )
  80 {
  81     for ( std::vector<String>::iterator aIter(aElements.begin()); aIter != aElements.end(); aIter++ )
  82         if ( *aIter == rName )          //! ignore case
  83         {
  84             aElements.erase( aIter );   // found -> remove
  85             return true;                // don't have to look further
  86         }
  87
  88     return false;   // not found
  89 }
  90
  91 bool ScDPSaveGroupItem::IsEmpty() const
  92 {
  93     return aElements.empty();
  94 }
  95
  96 size_t ScDPSaveGroupItem::GetElementCount() const
  97 {
  98     return aElements.size();
  99 }
 100
 101 const String* ScDPSaveGroupItem::GetElementByIndex( size_t nIndex ) const
 102 {
 103     return (nIndex < aElements.size()) ? &aElements[ nIndex ] : 0;
 104 }
 105
 106 void ScDPSaveGroupItem::Rename( const String& rNewName )
 107 {
 108     aGroupName = rNewName;
 109 }
 110
 111 void ScDPSaveGroupItem::RemoveElementsFromGroups( ScDPSaveGroupDimension& rDimension ) const
 112 {
 113     // remove this group's elements from their groups in rDimension
 114     // (rDimension must be a different dimension from the one which contains this)
 115
 116     for ( std::vector<String>::const_iterator aIter(aElements.begin()); aIter != aElements.end(); aIter++ )
 117         rDimension.RemoveFromGroups( *aIter );
 118 }
 119
 120 void ScDPSaveGroupItem::AddToData( ScDPGroupDimension& rDataDim, SvNumberFormatter* pFormatter ) const
 121 {
 122     ScDPGroupItem aGroup( aGroupName );
 123     ScDPItemData aData;
 124
 125     for ( std::vector<String>::const_iterator aIter(aElements.begin()); aIter != aElements.end(); aIter++ )
 126     {
 127         sal_uInt32 nFormat = 0;      //! ...
 128         double fValue;
 129         if ( pFormatter->IsNumberFormat( *aIter, nFormat, fValue ) )
 130             aData = ScDPItemData( *aIter, fValue, TRUE );
 131         else
 132             aData.SetString( *aIter );
 133
 134         aGroup.AddElement( aData );
 135         //! for numeric data, look at source members?
 136     }
 137
 138     rDataDim.AddItem( aGroup );
 139 }
 140
 141 // -----------------------------------------------------------------------
 142
 143 ScDPSaveGroupDimension::ScDPSaveGroupDimension( const String& rSource, const String& rName ) :
 144     aSourceDim( rSource ),
 145     aGroupDimName( rName ),
 146     nDatePart( 0 )
 147 {
 148 }
 149
 150 ScDPSaveGroupDimension::ScDPSaveGroupDimension( const ScDPSaveGroupDimension& r ) :
 151     aSourceDim( r.aSourceDim ),
 152     aGroupDimName( r.aGroupDimName ),
 153     aGroups( r.aGroups ),
 154     aDateInfo( r.aDateInfo ),
 155     nDatePart( r.nDatePart )
 156 {
 157 }
 158
 159 ScDPSaveGroupDimension::~ScDPSaveGroupDimension()
 160 {
 161 }
 162
 163 void ScDPSaveGroupDimension::SetDateInfo( const ScDPNumGroupInfo& rInfo, sal_Int32 nPart )
 164 {
 165     aDateInfo = rInfo;
 166     nDatePart = nPart;
 167 }
 168
 169 void ScDPSaveGroupDimension::AddGroupItem( const ScDPSaveGroupItem& rItem )
 170 {
 171     aGroups.push_back( rItem );
 172 }
 173
 174 String ScDPSaveGroupDimension::CreateGroupName( const String& rPrefix )
 175 {
 176     // create a name for a new group, using "Group1", "Group2" etc. (translated prefix in rPrefix)
 177
 178     //! look in all dimensions, to avoid clashes with automatic groups (=name of base element)?
 179     //! (only dimensions for the same base)
 180
 181     sal_Int32 nAdd = 1;                                 // first try is "Group1"
 182     const sal_Int32 nMaxAdd = nAdd + aGroups.size();    // limit the loop
 183     while ( nAdd <= nMaxAdd )
 184     {
 185         String aGroupName( rPrefix );
 186         aGroupName.Append( String::CreateFromInt32( nAdd ) );
 187         bool bExists = false;
 188
 189         // look for existing groups
 190         for ( ScDPSaveGroupItemVec::const_iterator aIter(aGroups.begin());
 191                                     aIter != aGroups.end() && !bExists; aIter++ )
 192             if ( aIter->GetGroupName() == aGroupName )         //! ignore case
 193                 bExists = true;
 194
 195         if ( !bExists )
 196             return aGroupName;          // found a new name
 197
 198         ++nAdd;                         // continue with higher number
 199     }
 200
 201     DBG_ERROR("CreateGroupName: no valid name found");
 202     return EMPTY_STRING;
 203 }
 204
 205 const ScDPSaveGroupItem* ScDPSaveGroupDimension::GetNamedGroup( const String& rGroupName ) const
 206 {
 207     return const_cast< ScDPSaveGroupDimension* >( this )->GetNamedGroupAcc( rGroupName );
 208 }
 209
 210 ScDPSaveGroupItem* ScDPSaveGroupDimension::GetNamedGroupAcc( const String& rGroupName )
 211 {
 212     for ( ScDPSaveGroupItemVec::iterator aIter(aGroups.begin()); aIter != aGroups.end(); aIter++ )
 213         if ( aIter->GetGroupName() == rGroupName )         //! ignore case
 214             return &*aIter;
 215
 216     return NULL;        // none found
 217 }
 218
 219 long ScDPSaveGroupDimension::GetGroupCount() const
 220 {
 221     return aGroups.size();
 222 }
 223
 224 const ScDPSaveGroupItem* ScDPSaveGroupDimension::GetGroupByIndex( long nIndex ) const
 225 {
 226     return const_cast< ScDPSaveGroupDimension* >( this )->GetGroupAccByIndex( nIndex );
 227 }
 228
 229 ScDPSaveGroupItem* ScDPSaveGroupDimension::GetGroupAccByIndex( long nIndex )
 230 {
 231     return &aGroups[nIndex];
 232 }
 233
 234 void ScDPSaveGroupDimension::RemoveFromGroups( const String& rItemName )
 235 {
 236     //  if the item is in any group, remove it from the group,
 237     //  also remove the group if it is empty afterwards
 238
 239     for ( ScDPSaveGroupItemVec::iterator aIter(aGroups.begin()); aIter != aGroups.end(); aIter++ )
 240         if ( aIter->RemoveElement( rItemName ) )
 241         {
 242             if ( aIter->IsEmpty() )         // removed last item from the group?
 243                 aGroups.erase( aIter );     // then remove the group
 244
 245             return;     // don't have to look further
 246         }
 247 }
 248
 249 void ScDPSaveGroupDimension::RemoveGroup( const String& rGroupName )
 250 {
 251     for ( ScDPSaveGroupItemVec::iterator aIter(aGroups.begin()); aIter != aGroups.end(); aIter++ )
 252         if ( aIter->GetGroupName() == rGroupName )          //! ignore case
 253         {
 254             aGroups.erase( aIter );
 255             return;                     // don't have to look further
 256         }
 257 }
 258
 259 bool ScDPSaveGroupDimension::IsEmpty() const
 260 {
 261     return aGroups.empty();
 262 }
 263
 264 bool ScDPSaveGroupDimension::HasOnlyHidden( const ScStrCollection& rVisible )
 265 {
 266     // check if there are only groups that don't appear in the list of visible names
 267
 268     bool bAllHidden = true;
 269     for ( ScDPSaveGroupItemVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end() && bAllHidden; aIter++ )
 270     {
 271         StrData aSearch( aIter->GetGroupName() );
 272         USHORT nCollIndex;
 273         if ( rVisible.Search( &aSearch, nCollIndex ) )
 274             bAllHidden = false;                             // found one that is visible
 275     }
 276     return bAllHidden;
 277 }
 278
 279 void ScDPSaveGroupDimension::Rename( const String& rNewName )
 280 {
 281     aGroupDimName = rNewName;
 282 }
 283
 284 void ScDPSaveGroupDimension::AddToData( ScDPGroupTableData& rData ) const
 285 {
 286     long nSourceIndex = rData.GetDimensionIndex( aSourceDim );
 287     if ( nSourceIndex >= 0 )
 288     {
 289         ScDPGroupDimension aDim( nSourceIndex, aGroupDimName );
 290         if ( nDatePart )
 291         {
 292             // date grouping
 293
 294             aDim.MakeDateHelper( aDateInfo, nDatePart );
 295         }
 296         else
 297         {
 298             // normal (manual) grouping
 299
 300             SvNumberFormatter* pFormatter = rData.GetDocument()->GetFormatTable();
 301
 302             for ( ScDPSaveGroupItemVec::const_iterator aIter(aGroups.begin()); aIter != aGroups.end(); aIter++ )
 303                 aIter->AddToData( aDim, pFormatter );
 304         }
 305
 306         rData.AddGroupDimension( aDim );
 307     }
 308 }
 309
 310 // -----------------------------------------------------------------------
 311
 312 ScDPSaveNumGroupDimension::ScDPSaveNumGroupDimension( const String& rName, const ScDPNumGroupInfo& rInfo ) :
 313     aDimensionName( rName ),
 314     aGroupInfo( rInfo ),
 315     nDatePart( 0 )
 316 {
 317 }
 318
 319 ScDPSaveNumGroupDimension::ScDPSaveNumGroupDimension( const ScDPSaveNumGroupDimension& r ) :
 320     aDimensionName( r.aDimensionName ),
 321     aGroupInfo( r.aGroupInfo ),
 322     aDateInfo( r.aDateInfo ),
 323     nDatePart( r.nDatePart )
 324 {
 325 }
 326
 327 ScDPSaveNumGroupDimension::~ScDPSaveNumGroupDimension()
 328 {
 329 }
 330
 331 void ScDPSaveNumGroupDimension::AddToData( ScDPGroupTableData& rData ) const
 332 {
 333     long nSource = rData.GetDimensionIndex( aDimensionName );
 334     if ( nSource >= 0 )
 335     {
 336         ScDPNumGroupDimension aDim( aGroupInfo );           // aGroupInfo: value grouping
 337         if ( nDatePart )
 338             aDim.MakeDateHelper( aDateInfo, nDatePart );    // date grouping
 339
 340         rData.SetNumGroupDimension( nSource, aDim );
 341     }
 342 }
 343
 344 void ScDPSaveNumGroupDimension::SetGroupInfo( const ScDPNumGroupInfo& rNew )
 345 {
 346     aGroupInfo = rNew;
 347 }
 348
 349 void ScDPSaveNumGroupDimension::SetDateInfo( const ScDPNumGroupInfo& rInfo, sal_Int32 nPart )
 350 {
 351     aDateInfo = rInfo;
 352     nDatePart = nPart;
 353 }
 354
 355 // -----------------------------------------------------------------------
 356
 357 ScDPDimensionSaveData::ScDPDimensionSaveData()
 358 {
 359 }
 360
 361 ScDPDimensionSaveData::ScDPDimensionSaveData( const ScDPDimensionSaveData& r ) :
 362     aGroupDimensions( r.aGroupDimensions ),
 363     aNumGroupDimensions( r.aNumGroupDimensions )
 364 {
 365 }
 366
 367 ScDPDimensionSaveData::~ScDPDimensionSaveData()
 368 {
 369 }
 370
 371 bool ScDPDimensionSaveData::operator==( const ScDPDimensionSaveData& ) const
 372 {
 373     return false;
 374 }
 375
 376 void ScDPDimensionSaveData::AddGroupDimension( const ScDPSaveGroupDimension& rGroup )
 377 {
 378     aGroupDimensions.push_back( rGroup );
 379 }
 380
 381 void ScDPDimensionSaveData::AddNumGroupDimension( const ScDPSaveNumGroupDimension& rGroup )
 382 {
 383     aNumGroupDimensions.push_back( rGroup );
 384 }
 385
 386 void ScDPDimensionSaveData::RemoveGroupDimension( const String& rDimensionName )
 387 {
 388     for ( ScDPSaveGroupDimensionVec::iterator aIter(aGroupDimensions.begin());
 389                                         aIter != aGroupDimensions.end(); aIter++ )
 390     {
 391         if ( aIter->GetGroupDimName() == rDimensionName )       //! ignore case
 392         {
 393             aGroupDimensions.erase( aIter );    // found -> remove
 394             return;                             // don't have to look further
 395         }
 396     }
 397 }
 398
 399 void ScDPDimensionSaveData::RemoveNumGroupDimension( const String& rDimensionName )
 400 {
 401     for ( ScDPSaveNumGroupDimensionVec::iterator aIter(aNumGroupDimensions.begin());
 402                                            aIter != aNumGroupDimensions.end(); aIter++ )
 403     {
 404         if ( aIter->GetDimensionName() == rDimensionName )      //! ignore case
 405         {
 406             aNumGroupDimensions.erase( aIter );    // found -> remove
 407             return;                                // don't have to look further
 408         }
 409     }
 410 }
 411
 412 void ScDPDimensionSaveData::WriteToData( ScDPGroupTableData& rData ) const
 413 {
 414     //  rData is assumed to be empty
 415     //  AddToData also handles date grouping
 416
 417     for ( ScDPSaveGroupDimensionVec::const_iterator aIter(aGroupDimensions.begin());
 418                                      aIter != aGroupDimensions.end(); aIter++ )
 419         aIter->AddToData( rData );
 420
 421     for ( ScDPSaveNumGroupDimensionVec::const_iterator aNumIter(aNumGroupDimensions.begin());
 422                                         aNumIter != aNumGroupDimensions.end(); aNumIter++ )
 423         aNumIter->AddToData( rData );
 424 }
 425
 426 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetGroupDimAccForBase( const String& rBaseName )
 427 {
 428     String aOrigBase( rBaseName );      // the original base dim in the case of nested group dims
 429
 430     for ( ScDPSaveGroupDimensionVec::iterator aIter(aGroupDimensions.begin());
 431                                      aIter != aGroupDimensions.end(); aIter++ )
 432     {
 433         if ( aIter->GetSourceDimName() == aOrigBase )         //! ignore case
 434         {
 435             return &*aIter;             // return the first one directly - it's the immediate derivative
 436         }
 437         else if ( aIter->GetGroupDimName() == aOrigBase )
 438         {
 439             // found the definition of rBaseName in the array - look for the next occurrence
 440             // of this definitions's base
 441
 442             aOrigBase = aIter->GetSourceDimName();      // and continue the loop
 443         }
 444     }
 445
 446     return NULL;    // none
 447 }
 448
 449 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetGroupDimForBase( const String& rBaseName ) const
 450 {
 451     return const_cast< ScDPDimensionSaveData* >( this )->GetGroupDimAccForBase( rBaseName );
 452 }
 453
 454 const ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNamedGroupDim( const String& rGroupDim ) const
 455 {
 456     return const_cast< ScDPDimensionSaveData* >( this )->GetNamedGroupDimAcc( rGroupDim );
 457 }
 458
 459 const ScDPSaveNumGroupDimension* ScDPDimensionSaveData::GetNumGroupDim( const String& rName ) const
 460 {
 461     return const_cast< ScDPDimensionSaveData* >( this )->GetNumGroupDimAcc( rName );
 462 }
 463
 464 ScDPSaveGroupDimension* ScDPDimensionSaveData::GetNamedGroupDimAcc( const String& rGroupDim )
 465 {
 466     for ( ScDPSaveGroupDimensionVec::iterator aIter(aGroupDimensions.begin());
 467                                      aIter != aGroupDimensions.end(); aIter++ )
 468         if ( aIter->GetGroupDimName() == rGroupDim )         //! ignore case
 469             return &*aIter;            // there should be only one - use it directly
 470
 471     return NULL;    // none
 472 }
 473
 474 ScDPSaveNumGroupDimension* ScDPDimensionSaveData::GetNumGroupDimAcc( const String& rName )
 475 {
 476     for ( ScDPSaveNumGroupDimensionVec::iterator aIter(aNumGroupDimensions.begin());
 477                                         aIter != aNumGroupDimensions.end(); aIter++ )
 478         if ( aIter->GetDimensionName() == rName )         //! ignore case
 479             return &*aIter;            // there should be only one - use it directly
 480
 481     return NULL;    // none
 482 }
 483
 484 bool ScDPDimensionSaveData::HasGroupDimensions() const
 485 {
 486     return !aGroupDimensions.empty() || !aNumGroupDimensions.empty();
 487 }
 488
 489 sal_Int32 ScDPDimensionSaveData::CollectDateParts( const String& rBaseDimName ) const
 490 {
 491     sal_Int32 nParts = 0;
 492     const ScDPSaveNumGroupDimension* pNumDim = GetNumGroupDim( rBaseDimName );
 493     if ( pNumDim )
 494         nParts |= pNumDim->GetDatePart();
 495
 496     for ( ScDPSaveGroupDimensionVec::const_iterator aIter(aGroupDimensions.begin());
 497                                      aIter != aGroupDimensions.end(); aIter++ )
 498         if ( aIter->GetSourceDimName() == rBaseDimName )         //! ignore case
 499         {
 500             nParts |= aIter->GetDatePart();
 501             // continue loop, collect parts from all matching group dimensions
 502         }
 503
 504     return nParts;
 505 }
 506
 507 String ScDPDimensionSaveData::CreateGroupDimName( const String& rSourceName,
 508                                         const ScDPObject& rObject, bool bAllowSource,
 509                                         const std::vector<String>* pDeletedNames )
 510 {
 511     // create a name for the new dimension by appending a number to the original
 512     // dimension's name
 513
 514     bool bUseSource = bAllowSource;     // if set, try the unchanged original name first
 515
 516     sal_Int32 nAdd = 2;                 // first try is "Name2"
 517     const sal_Int32 nMaxAdd = 1000;     // limit the loop
 518     while ( nAdd <= nMaxAdd )
 519     {
 520         String aDimName( rSourceName );
 521         if ( !bUseSource )
 522             aDimName.Append( String::CreateFromInt32( nAdd ) );
 523         bool bExists = false;
 524
 525         // look for existing group dimensions
 526         for ( ScDPSaveGroupDimensionVec::const_iterator aIter(aGroupDimensions.begin());
 527                                          aIter != aGroupDimensions.end() && !bExists; aIter++ )
 528             if ( aIter->GetGroupDimName() == aDimName )         //! ignore case
 529                 bExists = true;
 530
 531         // look for base dimensions that happen to have that name
 532         if ( !bExists && rObject.IsDimNameInUse( aDimName ) )
 533         {
 534             if ( pDeletedNames &&
 535                  std::find( pDeletedNames->begin(), pDeletedNames->end(), aDimName ) != pDeletedNames->end() )
 536             {
 537                 // allow the name anyway if the name is in pDeletedNames
 538             }
 539             else
 540                 bExists = true;
 541         }
 542
 543         if ( !bExists )
 544             return aDimName;            // found a new name
 545
 546         if ( bUseSource )
 547             bUseSource = false;
 548         else
 549             ++nAdd;                     // continue with higher number
 550     }
 551     DBG_ERROR("CreateGroupDimName: no valid name found");
 552     return EMPTY_STRING;
 553 }
 554