tools/source/memtools/multisel.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 <tools/debug.hxx>
  21 #include <tools/multisel.hxx>
  22
  23 #include <rtl/ustrbuf.hxx>
  24
  25 void MultiSelection::ImplClear()
  26 {
  27     // no selected indexes
  28     nSelCount = 0;
  29     aSels.clear();
  30 }
  31
  32 sal_Int32 MultiSelection::ImplFindSubSelection( sal_Int32 nIndex ) const
  33 {
  34     // iterate through the sub selections
  35     sal_Int32 n = 0;
  36     for ( ;
  37           n < sal_Int32(aSels.size()) && nIndex > aSels[ n ].Max();
  38           ++n ) {} /* empty loop */
  39     return n;
  40 }
  41
  42 void MultiSelection::ImplMergeSubSelections( sal_Int32 nPos1, sal_Int32 nPos2 )
  43 {
  44     // didn't a sub selection at nPos2 exist?
  45     if ( nPos2 >= sal_Int32(aSels.size()) )
  46         return;
  47
  48     // did the sub selections touch each other?
  49     if ( (aSels[ nPos1 ].Max() + 1) == aSels[ nPos2 ].Min() )
  50     {
  51         // merge them
  52         aSels[ nPos1 ].Max() = aSels[ nPos2 ].Max();
  53         aSels.erase( aSels.begin() + nPos2 );
  54     }
  55 }
  56
  57 MultiSelection::MultiSelection():
  58     aTotRange( 0, -1 ),
  59     nCurSubSel(0),
  60     nCurIndex(0),
  61     nSelCount(0),
  62     bCurValid(false)
  63 {
  64 }
  65
  66 void MultiSelection::Reset()
  67 {
  68     aTotRange = Range(0, -1);
  69     bCurValid = false;
  70     // clear the old sub selections
  71     ImplClear();
  72 }
  73
  74 MultiSelection::MultiSelection( const MultiSelection& rOrig ) :
  75     aTotRange(rOrig.aTotRange),
  76     nSelCount(rOrig.nSelCount),
  77     bCurValid(rOrig.bCurValid)
  78 {
  79     if ( bCurValid )
  80     {
  81         nCurSubSel = rOrig.nCurSubSel;
  82         nCurIndex = rOrig.nCurIndex;
  83     }
  84     else
  85     {
  86         nCurSubSel = 0;
  87         nCurIndex = 0;
  88     }
  89
  90     // copy the sub selections
  91     for (const Range & rSel : rOrig.aSels)
  92         aSels.push_back( rSel );
  93 }
  94
  95 MultiSelection::MultiSelection( const Range& rRange ):
  96     aTotRange(rRange),
  97     nCurSubSel(0),
  98     nCurIndex(0),
  99     nSelCount(0),
 100     bCurValid(false)
 101 {
 102 }
 103
 104 MultiSelection::~MultiSelection()
 105 {
 106 }
 107
 108 MultiSelection& MultiSelection::operator= ( const MultiSelection& rOrig )
 109 {
 110     aTotRange = rOrig.aTotRange;
 111     bCurValid = rOrig.bCurValid;
 112     if ( bCurValid )
 113     {
 114         nCurSubSel = rOrig.nCurSubSel;
 115         nCurIndex = rOrig.nCurIndex;
 116     }
 117
 118     // clear the old and copy the sub selections
 119     ImplClear();
 120     for (const Range& rSel : rOrig.aSels)
 121         aSels.push_back( rSel );
 122     nSelCount = rOrig.nSelCount;
 123
 124     return *this;
 125 }
 126
 127 void MultiSelection::SelectAll( bool bSelect )
 128 {
 129     ImplClear();
 130     if ( bSelect )
 131     {
 132         aSels.push_back( aTotRange );
 133         nSelCount = aTotRange.Len();
 134     }
 135 }
 136
 137 bool MultiSelection::Select( sal_Int32 nIndex, bool bSelect )
 138 {
 139     DBG_ASSERT( aTotRange.IsInside(nIndex), "selected index out of range" );
 140
 141     // out of range?
 142     if ( !aTotRange.IsInside(nIndex) )
 143         return false;
 144
 145     // find the virtual target position
 146     sal_Int32 nSubSelPos = ImplFindSubSelection( nIndex );
 147
 148     if ( bSelect )
 149     {
 150         // is it included in the found sub selection?
 151         if ( nSubSelPos < sal_Int32(aSels.size()) && aSels[ nSubSelPos ].IsInside( nIndex ) )
 152             // already selected, nothing to do
 153             return false;
 154
 155         // it will become selected
 156         ++nSelCount;
 157
 158         // is it at the end of the previous sub selection
 159         if ( nSubSelPos > 0 &&
 160              aSels[ nSubSelPos-1 ].Max() == (nIndex-1) )
 161         {
 162             // expand the previous sub selection
 163             aSels[ nSubSelPos-1 ].Max() = nIndex;
 164
 165             // try to merge the previous sub selection
 166             ImplMergeSubSelections( nSubSelPos-1, nSubSelPos );
 167         }
 168         // is it at the beginning of the found sub selection
 169         else if (  nSubSelPos < sal_Int32(aSels.size())
 170                 && aSels[ nSubSelPos ].Min() == (nIndex+1)
 171         )
 172             // expand the found sub selection
 173             aSels[ nSubSelPos ].Min() = nIndex;
 174         else
 175         {
 176             // create a new sub selection
 177             if ( nSubSelPos < sal_Int32(aSels.size()) ) {
 178                 aSels.insert( aSels.begin() + nSubSelPos, Range( nIndex, nIndex ) );
 179             } else {
 180                 aSels.push_back( Range( nIndex, nIndex ) );
 181             }
 182             if ( bCurValid && nCurSubSel >= nSubSelPos )
 183                 ++nCurSubSel;
 184         }
 185     }
 186     else
 187     {
 188         // is it excluded from the found sub selection?
 189         if (  nSubSelPos >= sal_Int32(aSels.size())
 190            || !aSels[ nSubSelPos ].IsInside( nIndex )
 191         ) {
 192             // not selected, nothing to do
 193             return false;
 194         }
 195
 196         // it will become deselected
 197         --nSelCount;
 198
 199         // is it the only index in the found sub selection?
 200         if ( aSels[ nSubSelPos ].Len() == 1 )
 201         {
 202             // remove the complete sub selection
 203             aSels.erase( aSels.begin() + nSubSelPos );
 204             return true;
 205         }
 206
 207         // is it at the beginning of the found sub selection?
 208         if ( aSels[ nSubSelPos ].Min() == nIndex )
 209             ++aSels[ nSubSelPos ].Min();
 210         // is it at the end of the found sub selection?
 211         else if ( aSels[ nSubSelPos ].Max() == nIndex )
 212             --aSels[ nSubSelPos ].Max();
 213         // it is in the middle of the found sub selection?
 214         else
 215         {
 216             // split the sub selection
 217             if ( nSubSelPos < sal_Int32(aSels.size()) ) {
 218                 aSels.insert( aSels.begin() + nSubSelPos, Range( aSels[ nSubSelPos ].Min(), nIndex-1 ) );
 219             } else {
 220                 aSels.push_back( Range( aSels[ nSubSelPos ].Min(), nIndex-1 ) );
 221             }
 222             aSels[ nSubSelPos+1 ].Min() = nIndex + 1;
 223         }
 224     }
 225
 226     return true;
 227 }
 228
 229 void MultiSelection::Select( const Range& rIndexRange, bool bSelect )
 230 {
 231     sal_Int32 nOld;
 232
 233     sal_Int32 nTmpMin = rIndexRange.Min();
 234     sal_Int32 nTmpMax = rIndexRange.Max();
 235     sal_Int32 nCurMin = FirstSelected();
 236     sal_Int32 nCurMax = LastSelected();
 237     DBG_ASSERT(aTotRange.IsInside(nTmpMax), "selected index out of range" );
 238     DBG_ASSERT(aTotRange.IsInside(nTmpMin), "selected index out of range" );
 239
 240     // replace whole selection?
 241     if( aSels.empty() || (nTmpMin <= nCurMin && nTmpMax >= nCurMax ) )
 242     {
 243         ImplClear();
 244         if ( bSelect )
 245         {
 246             aSels.push_back( rIndexRange );
 247             nSelCount = rIndexRange.Len();
 248         }
 249         return;
 250     }
 251     // expand on left side?
 252     if( nTmpMax < nCurMin )
 253     {
 254         if( bSelect )
 255         {
 256             // extend first range?
 257             if( nCurMin > (nTmpMax+1)  )
 258             {
 259                 aSels.insert( aSels.begin(), rIndexRange );
 260                 nSelCount += rIndexRange.Len();
 261             }
 262             else
 263             {
 264                 auto & rRange = aSels.front();
 265                 nOld = rRange.Min();
 266                 rRange.Min() = nTmpMin;
 267                 nSelCount += ( nOld - nTmpMin );
 268             }
 269             bCurValid = false;
 270         }
 271         return;
 272     }
 273     // expand on right side?
 274     else if( nTmpMin > nCurMax )
 275     {
 276         if( bSelect )
 277         {
 278             // extend last range?
 279             if( nTmpMin > (nCurMax+1) )
 280             {
 281                 aSels.push_back( rIndexRange );
 282                 nSelCount += rIndexRange.Len();
 283             }
 284             else
 285             {
 286                 auto & rRange = aSels.back();
 287                 nOld = rRange.Max();
 288                 rRange.Max() = nTmpMax;
 289                 nSelCount += ( nTmpMax - nOld );
 290             }
 291             bCurValid = false;
 292         }
 293         return;
 294     }
 295
 296     // TODO here is potential for optimization
 297     while( nTmpMin <= nTmpMax )
 298     {
 299         Select( nTmpMin, bSelect );
 300         nTmpMin++;
 301     }
 302 }
 303
 304 bool MultiSelection::IsSelected( sal_Int32 nIndex ) const
 305 {
 306     // find the virtual target position
 307     sal_Int32 nSubSelPos = ImplFindSubSelection( nIndex );
 308
 309     return nSubSelPos < sal_Int32(aSels.size()) && aSels[ nSubSelPos ].IsInside(nIndex);
 310 }
 311
 312 void MultiSelection::Insert( sal_Int32 nIndex, sal_Int32 nCount )
 313 {
 314     // find the virtual target position
 315     sal_Int32 nSubSelPos = ImplFindSubSelection( nIndex );
 316
 317     // did we need to shift the sub selections?
 318     if ( nSubSelPos < sal_Int32(aSels.size()) )
 319     {   // did we insert an unselected into an existing sub selection?
 320         if (  aSels[ nSubSelPos ].Min() != nIndex
 321            && aSels[ nSubSelPos ].IsInside(nIndex)
 322         ) { // split the sub selection
 323             if ( nSubSelPos < sal_Int32(aSels.size()) ) {
 324                 aSels.insert( aSels.begin() + nSubSelPos, Range( aSels[ nSubSelPos ].Min(), nIndex-1 ) );
 325             } else {
 326                 aSels.push_back( Range( aSels[ nSubSelPos ].Min(), nIndex-1 ) );
 327             }
 328             ++nSubSelPos;
 329             aSels[ nSubSelPos ].Min() = nIndex;
 330         }
 331
 332         // shift the sub selections behind the inserting position
 333         for ( sal_Int32 nPos = nSubSelPos; nPos < sal_Int32(aSels.size()); ++nPos )
 334         {
 335             aSels[ nPos ].Min() += nCount;
 336             aSels[ nPos ].Max() += nCount;
 337         }
 338     }
 339
 340     bCurValid = false;
 341     aTotRange.Max() += nCount;
 342 }
 343
 344 void MultiSelection::Remove( sal_Int32 nIndex )
 345 {
 346     // find the virtual target position
 347     sal_Int32 nSubSelPos = ImplFindSubSelection( nIndex );
 348
 349     // did we remove from an existing sub selection?
 350     if (  nSubSelPos < sal_Int32(aSels.size())
 351        && aSels[ nSubSelPos ].IsInside(nIndex)
 352     ) {
 353         // does this sub selection only contain the index to be deleted
 354         if ( aSels[ nSubSelPos ].Len() == 1 ) {
 355             // completely remove the sub selection
 356             aSels.erase( aSels.begin() + nSubSelPos );
 357         } else {
 358             // shorten this sub selection
 359             --( aSels[ nSubSelPos++ ].Max() );
 360         }
 361
 362         // adjust the selected counter
 363         --nSelCount;
 364     }
 365
 366     // shift the sub selections behind the removed index
 367     for ( sal_Int32 nPos = nSubSelPos; nPos < sal_Int32(aSels.size()); ++nPos )
 368     {
 369         --( aSels[ nPos ].Min() );
 370         --( aSels[ nPos ].Max() );
 371     }
 372
 373     bCurValid = false;
 374     aTotRange.Max() -= 1;
 375 }
 376
 377 sal_Int32 MultiSelection::FirstSelected()
 378 {
 379     nCurSubSel = 0;
 380
 381     bCurValid = !aSels.empty();
 382     if ( !bCurValid )
 383         return SFX_ENDOFSELECTION;
 384
 385     nCurIndex = aSels[ 0 ].Min();
 386     return nCurIndex;
 387 }
 388
 389 sal_Int32 MultiSelection::LastSelected()
 390 {
 391     nCurSubSel = aSels.size() - 1;
 392     bCurValid = !aSels.empty();
 393
 394     if ( !bCurValid )
 395         return SFX_ENDOFSELECTION;
 396
 397     nCurIndex = aSels[ nCurSubSel ].Max();
 398     return nCurIndex;
 399 }
 400
 401 sal_Int32 MultiSelection::NextSelected()
 402 {
 403     if ( !bCurValid )
 404         return SFX_ENDOFSELECTION;
 405
 406     // is the next index in the current sub selection too?
 407     if ( nCurIndex < aSels[ nCurSubSel ].Max() )
 408         return ++nCurIndex;
 409
 410     // are there further sub selections?
 411     if ( ++nCurSubSel >= sal_Int32(aSels.size()) )
 412         // we are at the end!
 413         return SFX_ENDOFSELECTION;
 414
 415     nCurIndex = aSels[ nCurSubSel ].Min();
 416     return nCurIndex;
 417 }
 418
 419 void MultiSelection::SetTotalRange( const Range& rTotRange )
 420 {
 421     aTotRange = rTotRange;
 422
 423     // adjust lower boundary
 424     Range* pRange = aSels.empty() ? nullptr : &aSels.front();
 425     while( pRange )
 426     {
 427         if( pRange->Max() < aTotRange.Min() )
 428         {
 429             aSels.erase( aSels.begin() );
 430         }
 431         else if( pRange->Min() < aTotRange.Min() )
 432         {
 433             pRange->Min() = aTotRange.Min();
 434             break;
 435         }
 436         else
 437             break;
 438
 439         pRange = aSels.empty() ? nullptr : &aSels.front();
 440     }
 441
 442     // adjust upper boundary
 443     sal_Int32 nCount = aSels.size();
 444     while( nCount )
 445     {
 446         pRange = &aSels[ nCount - 1 ];
 447         if( pRange->Min() > aTotRange.Max() )
 448         {
 449             aSels.pop_back();
 450         }
 451         else if( pRange->Max() > aTotRange.Max() )
 452         {
 453             pRange->Max() = aTotRange.Max();
 454             break;
 455         }
 456         else
 457             break;
 458
 459         nCount = aSels.size();
 460     }
 461
 462     // re-calculate selection count
 463     nSelCount = 0;
 464     for (Range const & rSel : aSels)
 465         nSelCount += rSel.Len();
 466
 467     bCurValid = false;
 468     nCurIndex = 0;
 469 }
 470
 471 // StringRangeEnumerator
 472
 473 StringRangeEnumerator::StringRangeEnumerator( const OUString& i_rInput,
 474                                               sal_Int32 i_nMinNumber,
 475                                               sal_Int32 i_nMaxNumber,
 476                                               sal_Int32 i_nLogicalOffset
 477                                               )
 478     : mnCount( 0 )
 479     , mnMin( i_nMinNumber )
 480     , mnMax( i_nMaxNumber )
 481     , mnOffset( i_nLogicalOffset )
 482     , mbValidInput( false )
 483 {
 484     // Parse string only if boundaries are valid.
 485     if( mnMin >= 0 && mnMax >= 0 && mnMin <= mnMax )
 486         mbValidInput = setRange( i_rInput );
 487 }
 488
 489 bool StringRangeEnumerator::checkValue( sal_Int32 i_nValue, const o3tl::sorted_vector< sal_Int32 >* i_pPossibleValues ) const
 490 {
 491     if( i_nValue < 0 || i_nValue < mnMin || i_nValue > mnMax )
 492         return false;
 493     if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
 494         return false;
 495     return true;
 496 }
 497
 498 bool StringRangeEnumerator::insertRange( sal_Int32 i_nFirst, sal_Int32 i_nLast, bool bSequence )
 499 {
 500     bool bSuccess = true;
 501     if( bSequence )
 502     {
 503         // Check if the range is completely outside of possible pages range
 504         if ((i_nFirst < mnMin && i_nLast < mnMin) ||
 505             (i_nFirst > mnMax && i_nLast > mnMax))
 506             return false;
 507         if( i_nFirst < mnMin )
 508             i_nFirst = mnMin;
 509         if( i_nFirst > mnMax )
 510             i_nFirst = mnMax;
 511         if( i_nLast < mnMin )
 512             i_nLast = mnMin;
 513         if( i_nLast > mnMax )
 514             i_nLast = mnMax;
 515         if( checkValue( i_nFirst ) && checkValue( i_nLast ) )
 516         {
 517             maSequence.push_back( Range( i_nFirst, i_nLast ) );
 518             sal_Int32 nNumber = i_nLast - i_nFirst;
 519             nNumber = nNumber < 0 ? -nNumber : nNumber;
 520             mnCount += nNumber + 1;
 521         }
 522         else
 523             bSuccess = false;
 524     }
 525     else
 526     {
 527         if( checkValue( i_nFirst ) )
 528         {
 529             maSequence.push_back( Range( i_nFirst, i_nFirst ) );
 530             mnCount++;
 531         }
 532         else if( checkValue( i_nLast ) )
 533         {
 534             maSequence.push_back( Range( i_nLast, i_nLast ) );
 535             mnCount++;
 536         }
 537         else
 538             bSuccess = false;
 539     }
 540
 541     return bSuccess;
 542 }
 543
 544 void StringRangeEnumerator::insertJoinedRanges(
 545     const std::vector< sal_Int32 >& rNumbers )
 546 {
 547     size_t nCount = rNumbers.size();
 548     if( nCount == 0 )
 549         return;
 550
 551     if( nCount == 1 )
 552     {
 553         insertRange( rNumbers[0], -1, false );
 554         return;
 555     }
 556
 557     for( size_t i = 0; i < nCount - 1; i++ )
 558     {
 559         sal_Int32 nFirst = rNumbers[i];
 560         sal_Int32 nLast  = rNumbers[i + 1];
 561         if( i > 0 )
 562         {
 563             if     ( nFirst > nLast ) nFirst--;
 564             else if( nFirst < nLast ) nFirst++;
 565         }
 566
 567         insertRange( nFirst, nLast, nFirst != nLast );
 568     }
 569 }
 570
 571 bool StringRangeEnumerator::setRange( const OUString& i_rNewRange )
 572 {
 573     mnCount = 0;
 574     maSequence.clear();
 575
 576     const sal_Unicode* pInput = i_rNewRange.getStr();
 577     OUStringBuffer aNumberBuf( 16 );
 578     std::vector< sal_Int32 > aNumbers;
 579     bool bSequence = false;
 580     while( *pInput )
 581     {
 582         while( *pInput >= '0' && *pInput <= '9' )
 583             aNumberBuf.append( *pInput++ );
 584         if( !aNumberBuf.isEmpty() )
 585         {
 586             sal_Int32 nNumber = aNumberBuf.makeStringAndClear().toInt32() + mnOffset;
 587             aNumbers.push_back( nNumber );
 588             bSequence = false;
 589         }
 590
 591         if( *pInput == '-' )
 592         {
 593             bSequence = true;
 594             if( aNumbers.empty() )
 595             {
 596                 // push out-of-range small value, to exclude ranges totally outside of possible range
 597                 aNumbers.push_back( mnMin-1 );
 598             }
 599         }
 600         else if( *pInput == ',' || *pInput == ';' )
 601         {
 602             if( bSequence && !aNumbers.empty() )
 603             {
 604                 // push out-of-range large value, to exclude ranges totally outside of possible range
 605                 aNumbers.push_back( mnMax+1 );
 606             }
 607             insertJoinedRanges( aNumbers );
 608
 609             aNumbers.clear();
 610             bSequence = false;
 611         }
 612         else if( *pInput && *pInput != ' ' )
 613             return false; // parse error
 614
 615         if( *pInput )
 616             pInput++;
 617     }
 618     // insert last entries
 619     if( bSequence && !aNumbers.empty() )
 620     {
 621         // push out-of-range large value, to exclude ranges totally outside of possible range
 622         aNumbers.push_back( mnMax+1 );
 623     }
 624     insertJoinedRanges( aNumbers );
 625
 626     return true;
 627 }
 628
 629 bool StringRangeEnumerator::hasValue( sal_Int32 i_nValue, const o3tl::sorted_vector< sal_Int32 >* i_pPossibleValues ) const
 630 {
 631     if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
 632         return false;
 633     size_t n = maSequence.size();
 634     for( size_t i= 0; i < n; ++i )
 635     {
 636         const StringRangeEnumerator::Range rRange( maSequence[i] );
 637         if( rRange.nFirst < rRange.nLast )
 638         {
 639             if( i_nValue >= rRange.nFirst && i_nValue <= rRange.nLast )
 640                 return true;
 641         }
 642         else
 643         {
 644             if( i_nValue >= rRange.nLast && i_nValue <= rRange.nFirst )
 645                 return true;
 646         }
 647     }
 648     return false;
 649 }
 650
 651 StringRangeEnumerator::Iterator& StringRangeEnumerator::Iterator::operator++()
 652 {
 653     if( nRangeIndex >= 0 && nCurrent >= 0 && pEnumerator )
 654     {
 655         const StringRangeEnumerator::Range& rRange( pEnumerator->maSequence[nRangeIndex] );
 656         bool bRangeChange = false;
 657         if( rRange.nLast < rRange.nFirst )
 658         {
 659             // backward range
 660             if( nCurrent > rRange.nLast )
 661                 nCurrent--;
 662             else
 663                 bRangeChange = true;
 664         }
 665         else
 666         {
 667             // forward range
 668             if( nCurrent < rRange.nLast )
 669                 nCurrent++;
 670             else
 671                 bRangeChange = true;
 672         }
 673         if( bRangeChange )
 674         {
 675             nRangeIndex++;
 676             if( size_t(nRangeIndex) == pEnumerator->maSequence.size() )
 677             {
 678                 // reached the end
 679                 nRangeIndex = nCurrent = -1;
 680             }
 681             else
 682                 nCurrent = pEnumerator->maSequence[nRangeIndex].nFirst;
 683         }
 684         if( nRangeIndex != -1 && nCurrent != -1 )
 685         {
 686             if( ! pEnumerator->checkValue( nCurrent, pPossibleValues ) )
 687                 return ++(*this);
 688         }
 689     }
 690     return *this;
 691 }
 692
 693
 694 bool StringRangeEnumerator::Iterator::operator==( const Iterator& i_rCompare ) const
 695 {
 696     return i_rCompare.pEnumerator == pEnumerator && i_rCompare.nRangeIndex == nRangeIndex && i_rCompare.nCurrent == nCurrent;
 697 }
 698
 699 StringRangeEnumerator::Iterator StringRangeEnumerator::begin( const o3tl::sorted_vector< sal_Int32 >* i_pPossibleValues ) const
 700 {
 701     StringRangeEnumerator::Iterator it( this,
 702                                         i_pPossibleValues,
 703                                         maSequence.empty() ? -1 : 0,
 704                                         maSequence.empty() ? -1 : maSequence[0].nFirst );
 705     if( ! checkValue(*it, i_pPossibleValues ) )
 706         ++it;
 707     return it;
 708 }
 709
 710 StringRangeEnumerator::Iterator StringRangeEnumerator::end( const o3tl::sorted_vector< sal_Int32 >* i_pPossibleValues ) const
 711 {
 712     return StringRangeEnumerator::Iterator( this, i_pPossibleValues, -1, -1 );
 713 }
 714
 715 bool StringRangeEnumerator::getRangesFromString( const OUString& i_rPageRange,
 716                                                  std::vector< sal_Int32 >& o_rPageVector,
 717                                                  sal_Int32 i_nMinNumber,
 718                                                  sal_Int32 i_nMaxNumber,
 719                                                  sal_Int32 i_nLogicalOffset,
 720                                                  o3tl::sorted_vector< sal_Int32 > const * i_pPossibleValues
 721                                                )
 722 {
 723     o_rPageVector.clear();
 724
 725     StringRangeEnumerator aEnum( i_rPageRange, i_nMinNumber, i_nMaxNumber, i_nLogicalOffset ) ;
 726
 727     //Even if the input range wasn't completely valid, return what ranges could
 728     //be extracted from the input.
 729     o_rPageVector.reserve( static_cast< size_t >( aEnum.size() ) );
 730     for( StringRangeEnumerator::Iterator it = aEnum.begin( i_pPossibleValues );
 731          it != aEnum.end( i_pPossibleValues ); ++it )
 732     {
 733         o_rPageVector.push_back( *it );
 734     }
 735
 736     return aEnum.mbValidInput;
 737 }
 738
 739 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */