sw/source/core/txtnode/ndhints.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 <editeng/rsiditem.hxx>
  21 #include <sal/log.hxx>
  22 #include <txatbase.hxx>
  23 #include <ndhints.hxx>
  24 #include <txtatr.hxx>
  25
  26 #ifdef DBG_UTIL
  27 #include <pam.hxx>
  28 #include <fmtautofmt.hxx>
  29 #endif
  30
  31 /// sort order: Start, End (reverse), Which (reverse),
  32 /// (char style: sort number), at last the pointer
  33 static bool CompareSwpHtStart( const SwTextAttr* lhs, const SwTextAttr* rhs )
  34 {
  35     const SwTextAttr &rHt1 = *lhs;
  36     const SwTextAttr &rHt2 = *rhs;
  37     if ( rHt1.GetStart() == rHt2.GetStart() )
  38     {
  39         const sal_Int32 nHt1 = rHt1.GetAnyEnd();
  40         const sal_Int32 nHt2 = rHt2.GetAnyEnd();
  41         if ( nHt1 == nHt2 )
  42         {
  43             const sal_uInt16 nWhich1 = rHt1.Which();
  44             const sal_uInt16 nWhich2 = rHt2.Which();
  45             if ( nWhich1 == nWhich2 )
  46             {
  47                 if ( RES_TXTATR_CHARFMT == nWhich1 )
  48                 {
  49                     const sal_uInt16 nS1 =
  50                         static_txtattr_cast<const SwTextCharFormat&>(rHt1).GetSortNumber();
  51                     const sal_uInt16 nS2 =
  52                         static_txtattr_cast<const SwTextCharFormat&>(rHt2).GetSortNumber();
  53                     if ( nS1 != nS2 ) // robust
  54                         return nS1 < nS2;
  55                 }
  56
  57                 return reinterpret_cast<sal_IntPtr>(&rHt1) < reinterpret_cast<sal_IntPtr>(&rHt2);
  58             }
  59             // order is important! for requirements see hintids.hxx
  60             return ( nWhich1 > nWhich2 );
  61         }
  62         return ( nHt1 > nHt2 );
  63     }
  64     return ( rHt1.GetStart() < rHt2.GetStart() );
  65 }
  66
  67 /// sort order: Start
  68 /// (char style: sort number), at last the pointer
  69 namespace {
  70 struct CompareSwpHtStartOnly
  71 {
  72     bool operator()( const SwTextAttr* lhs, sal_Int32 rhs ) const
  73     {
  74         return lhs->GetStart() < rhs;
  75     }
  76     bool operator()( sal_Int32 lhs, const SwTextAttr* rhs ) const
  77     {
  78         return lhs < rhs->GetStart();
  79     }
  80 };
  81 struct CompareSwpHtEndOnly
  82 {
  83     bool operator()( const SwTextAttr* lhs, sal_Int32 rhs ) const
  84     {
  85         return lhs->GetAnyEnd() < rhs;
  86     }
  87     bool operator()( sal_Int32 lhs, const SwTextAttr* rhs ) const
  88     {
  89         return lhs < rhs->GetAnyEnd();
  90     }
  91 };
  92 }
  93
  94 /// sort order: Which, Start, End(reverse) at last the pointer
  95 bool CompareSwpHtWhichStart::operator()( const SwTextAttr* lhs, const sal_uInt16 nWhich ) const
  96 {
  97     return lhs->Which() < nWhich;
  98 }
  99 bool CompareSwpHtWhichStart::operator()( const SwTextAttr* lhs, const SwTextAttr* rhs ) const
 100 {
 101     const SwTextAttr &rHt1 = *lhs;
 102     const SwTextAttr &rHt2 = *rhs;
 103     const sal_uInt16 nWhich1 = rHt1.Which();
 104     const sal_uInt16 nWhich2 = rHt2.Which();
 105     if ( nWhich1 < nWhich2 )
 106         return true;
 107     if ( nWhich1 > nWhich2 )
 108         return false;
 109     if (rHt1.GetStart() < rHt2.GetStart())
 110         return true;
 111     if (rHt1.GetStart() > rHt2.GetStart())
 112         return false;
 113     if ( RES_TXTATR_CHARFMT == nWhich1 )
 114     {
 115         const sal_uInt16 nS1 =
 116                         static_txtattr_cast<const SwTextCharFormat&>(rHt1).GetSortNumber();
 117         const sal_uInt16 nS2 =
 118                         static_txtattr_cast<const SwTextCharFormat&>(rHt2).GetSortNumber();
 119         if ( nS1 != nS2 ) // robust
 120             return nS1 < nS2;
 121     }
 122     const sal_Int32 nEnd1 = rHt1.GetAnyEnd();
 123     const sal_Int32 nEnd2 = rHt2.GetAnyEnd();
 124     if ( nEnd1 > nEnd2 )
 125         return true;
 126     if ( nEnd1 < nEnd2 )
 127         return false;
 128     return reinterpret_cast<sal_IntPtr>(&rHt1) < reinterpret_cast<sal_IntPtr>(&rHt2);
 129 }
 130 bool CompareSwpHtWhichStart::operator()( const SwTextAttr* lhs, const WhichStartPair rhs ) const
 131 {
 132     if ( lhs->Which() < rhs.first )
 133         return true;
 134     if ( lhs->Which() > rhs.first )
 135         return false;
 136     return lhs->GetStart() < rhs.second;
 137 }
 138 bool CompareSwpHtWhichStart::operator()( const WhichStartPair lhs, const SwTextAttr* rhs ) const
 139 {
 140     if ( lhs.first < rhs->Which() )
 141         return true;
 142     if ( lhs.first > rhs->Which() )
 143         return false;
 144     return lhs.second < rhs->GetStart();
 145 }
 146
 147 /// sort order: End, Start(reverse), Which
 148 /// (char style: sort number), at last the pointer(reverse)
 149 bool CompareSwpHtEnd::operator()( sal_Int32 nEndPos, const SwTextAttr* rhs ) const
 150 {
 151     return nEndPos < rhs->GetAnyEnd();
 152 }
 153 bool CompareSwpHtEnd::operator()( const SwTextAttr* lhs, const SwTextAttr* rhs ) const
 154 {
 155     const SwTextAttr &rHt1 = *lhs;
 156     const SwTextAttr &rHt2 = *rhs;
 157     const sal_Int32 nHt1 = rHt1.GetAnyEnd();
 158     const sal_Int32 nHt2 = rHt2.GetAnyEnd();
 159     if ( nHt1 == nHt2 )
 160     {
 161         if ( rHt1.GetStart() == rHt2.GetStart() )
 162         {
 163             const sal_uInt16 nWhich1 = rHt1.Which();
 164             const sal_uInt16 nWhich2 = rHt2.Which();
 165             if ( nWhich1 == nWhich2 )
 166             {
 167                 if ( RES_TXTATR_CHARFMT == nWhich1 )
 168                 {
 169                     const sal_uInt16 nS1 =
 170                             static_txtattr_cast<const SwTextCharFormat&>(rHt1).GetSortNumber();
 171                     const sal_uInt16 nS2 =
 172                             static_txtattr_cast<const SwTextCharFormat&>(rHt2).GetSortNumber();
 173                     if ( nS1 != nS2 ) // robust
 174                         return nS1 > nS2;
 175                 }
 176
 177                 return reinterpret_cast<sal_IntPtr>(&rHt1) > reinterpret_cast<sal_IntPtr>(&rHt2);
 178             }
 179             // order is important! for requirements see hintids.hxx
 180             return ( nWhich1 < nWhich2 );
 181         }
 182         else
 183             return ( rHt1.GetStart() > rHt2.GetStart() );
 184     }
 185     return ( nHt1 < nHt2 );
 186 }
 187
 188 void SwpHints::Insert(SwTextAttr* pHt)
 189 {
 190     assert(std::find(m_HintsByStart.begin(), m_HintsByStart.end(), pHt)
 191             == m_HintsByStart.end()); // "Insert: hint already in HtStart"
 192     assert( pHt->m_pHints == nullptr );
 193     pHt->m_pHints = this;
 194
 195     ResortStartMap();
 196     ResortEndMap();
 197     ResortWhichMap();
 198
 199     auto it1 = std::lower_bound(m_HintsByStart.begin(), m_HintsByStart.end(), pHt, CompareSwpHtStart);
 200     m_HintsByStart.insert(it1, pHt);
 201
 202     auto it2 = std::lower_bound(m_HintsByEnd.begin(), m_HintsByEnd.end(), pHt, CompareSwpHtEnd());
 203     m_HintsByEnd.insert(it2, pHt);
 204
 205     auto it3 = std::lower_bound(m_HintsByWhichAndStart.begin(), m_HintsByWhichAndStart.end(), pHt, CompareSwpHtWhichStart());
 206     m_HintsByWhichAndStart.insert(it3, pHt);
 207 }
 208
 209 bool SwpHints::Contains( const SwTextAttr *pHt ) const
 210 {
 211     // DO NOT use find() or CHECK here!
 212     // if called from SwTextNode::InsertItem, pHt has already been deleted,
 213     // so it cannot be dereferenced
 214     return std::find(m_HintsByStart.begin(), m_HintsByStart.end(), pHt)
 215         != m_HintsByStart.end();
 216 }
 217
 218 #ifdef DBG_UTIL
 219
 220 #define CHECK_ERR(cond, text) \
 221         if(!(cond)) \
 222         { \
 223             SAL_WARN("sw.core", text); \
 224             Resort(); \
 225             return false; \
 226         }
 227
 228 bool SwpHints::Check(bool bPortionsMerged) const
 229 {
 230     // 1) both arrays have same size
 231     CHECK_ERR( m_HintsByStart.size() == m_HintsByEnd.size(),
 232         "HintsCheck: wrong sizes" );
 233     sal_Int32 nLastStart = 0;
 234     sal_Int32 nLastEnd   = 0;
 235
 236     const SwTextAttr *pLastStart = nullptr;
 237     const SwTextAttr *pLastEnd = nullptr;
 238     o3tl::sorted_vector<SwTextAttr const*> RsidOnlyAutoFormats;
 239     if (bPortionsMerged)
 240     {
 241         for (size_t i = 0; i < Count(); ++i)
 242         {
 243             SwTextAttr const*const pHint(m_HintsByStart[i]);
 244             if (RES_TXTATR_AUTOFMT == pHint->Which())
 245             {
 246                 std::shared_ptr<SfxItemSet> const & pSet(
 247                         pHint->GetAutoFormat().GetStyleHandle());
 248                 if (pSet->Count() == 1 && pSet->GetItem(RES_CHRATR_RSID, false))
 249                 {
 250                     RsidOnlyAutoFormats.insert(pHint);
 251                 }
 252             }
 253         }
 254     }
 255
 256     // --- cross checks ---
 257     // same pointers in both arrays
 258     auto tmpHintsByEnd = m_HintsByEnd;
 259     std::sort(tmpHintsByEnd.begin(), tmpHintsByEnd.end(), CompareSwpHtStart);
 260     CHECK_ERR( tmpHintsByEnd == m_HintsByStart, "HintsCheck: the two arrays do not contain the same set of pointers" );
 261
 262     for( size_t i = 0; i < Count(); ++i )
 263     {
 264         // --- check Starts ---
 265
 266         // 2a) valid pointer? depends on overwriting freed mem with 0xFF
 267         const SwTextAttr *pHt = m_HintsByStart[i];
 268         CHECK_ERR( 0xFF != *reinterpret_cast<unsigned char const *>(pHt), "HintsCheck: start ptr was deleted" );
 269
 270         // 3a) start sort order?
 271         sal_Int32 nIdx = pHt->GetStart();
 272         CHECK_ERR( nIdx >= nLastStart, "HintsCheck: starts are unsorted" );
 273
 274         // 4a) IsLessStart consistency
 275         if( pLastStart )
 276             CHECK_ERR( CompareSwpHtStart( pLastStart, pHt ), "HintsCheck: IsLastStart" );
 277
 278         nLastStart = nIdx;
 279         pLastStart = pHt;
 280
 281         // --- check Ends ---
 282
 283         // 2b) valid pointer? see DELETEFF
 284         const SwTextAttr *pHtEnd = m_HintsByEnd[i];
 285         CHECK_ERR( 0xFF != *reinterpret_cast<unsigned char const *>(pHtEnd), "HintsCheck: end ptr was deleted" );
 286
 287         // 3b) end sort order?
 288         nIdx = pHtEnd->GetAnyEnd();
 289         CHECK_ERR( nIdx >= nLastEnd, "HintsCheck: ends are unsorted" );
 290
 291         // 4b) IsLessEnd consistency
 292         if( pLastEnd )
 293             CHECK_ERR( CompareSwpHtEnd()( pLastEnd, pHtEnd ), "HintsCheck: IsLastEnd" );
 294
 295         nLastEnd = nIdx;
 296         pLastEnd = pHtEnd;
 297
 298         CHECK_ERR( COMPLETE_STRING != nIdx, "HintsCheck: no GetEndOf" );
 299
 300         // 7a) character attributes in array?
 301         sal_uInt16 nWhich = pHt->Which();
 302         CHECK_ERR( !isCHRATR(nWhich),
 303                    "HintsCheck: Character attribute in start array" );
 304
 305         // 7b) character attributes in array?
 306         nWhich = pHtEnd->Which();
 307         CHECK_ERR( !isCHRATR(nWhich),
 308                    "HintsCheck: Character attribute in end array" );
 309
 310         // 8) style portion check
 311         const SwTextAttr* pHtThis = m_HintsByStart[i];
 312         const SwTextAttr* pHtLast = i > 0 ? m_HintsByStart[i-1] : nullptr;
 313         CHECK_ERR( (0 == i)
 314             ||  (   (RES_TXTATR_CHARFMT != pHtLast->Which())
 315                 &&  (RES_TXTATR_AUTOFMT != pHtLast->Which()))
 316             ||  (   (RES_TXTATR_CHARFMT != pHtThis->Which())
 317                 &&  (RES_TXTATR_AUTOFMT != pHtThis->Which()))
 318             ||  (pHtThis->GetStart() >= *pHtLast->End()) // no overlap
 319             ||  (   (   (pHtThis->GetStart() == pHtLast->GetStart())
 320                     &&  (*pHtThis->End()   == *pHtLast->End())
 321                     ) // same range
 322                 &&  (   (pHtThis->Which() != RES_TXTATR_AUTOFMT)
 323                     ||  (pHtLast->Which() != RES_TXTATR_AUTOFMT)
 324                     ) // never two AUTOFMT on same range
 325                 &&  (   (pHtThis->Which() != RES_TXTATR_CHARFMT)
 326                     ||  (pHtLast->Which() != RES_TXTATR_CHARFMT)
 327                     ||  (static_txtattr_cast<const SwTextCharFormat *>(pHtThis)
 328                                 ->GetSortNumber() !=
 329                          static_txtattr_cast<const SwTextCharFormat *>(pHtLast)
 330                                 ->GetSortNumber())
 331                     ) // multiple CHARFMT on same range need distinct sorter
 332                 )
 333             ||  (pHtThis->GetStart() == *pHtThis->End()), // this empty
 334                    "HintsCheck: Portion inconsistency. "
 335                    "This can be temporarily ok during undo operations" );
 336
 337         // 8 1/2) format ignore start/end flag check
 338         // (problems because MergePortions buggy or not called)
 339         if (bPortionsMerged)
 340         {
 341             if (RES_TXTATR_AUTOFMT == pHt->Which() ||
 342                 RES_TXTATR_CHARFMT == pHt->Which())
 343             {
 344                 // mostly ignore the annoying no-length hints
 345                 // BuildPortions inserts these in the middle of an existing one
 346                 bool const bNoLength(pHt->GetStart() == *pHt->End());
 347                 bool bNeedContinuation(!bNoLength && pHt->IsFormatIgnoreEnd());
 348                 bool bForbidContinuation(!bNoLength && !bNeedContinuation);
 349                 if (RES_TXTATR_AUTOFMT == pHt->Which())
 350                 {
 351                     if (RsidOnlyAutoFormats.find(pHt) != RsidOnlyAutoFormats.end())
 352                     {
 353                         assert(pHt->IsFormatIgnoreStart());
 354                         bNeedContinuation = false;
 355                         // don't forbid continuation - may be other hint here!
 356                     }
 357                 }
 358                 if (bNeedContinuation || bForbidContinuation)
 359                 {
 360                     bool bFound(false);
 361                     for (size_t j = i + 1; j < Count(); ++j)
 362                     {
 363                         SwTextAttr *const pOther(m_HintsByStart[j]);
 364                         if (pOther->GetStart() > *pHt->End())
 365                         {
 366                             break; // done
 367                         }
 368                         else if (pOther->GetStart() == pOther->GetAnyEnd())
 369                         {
 370                             continue; // empty hint: ignore
 371                         }
 372                         else if (pOther->GetStart() == *pHt->End())
 373                         {
 374                             if (RES_TXTATR_AUTOFMT == pOther->Which() ||
 375                                 RES_TXTATR_CHARFMT == pOther->Which())
 376                             {   // multiple charfmt on same range must all match
 377                                 if (bNeedContinuation)
 378                                 {
 379                                     assert(pOther->IsFormatIgnoreStart());
 380                                     bFound = true;
 381                                 }
 382                                 else if (bForbidContinuation &&
 383                                          (RsidOnlyAutoFormats.find(pOther) ==
 384                                           RsidOnlyAutoFormats.end()))
 385                                 {
 386                                     assert(!pOther->IsFormatIgnoreStart());
 387                                 }
 388                             }
 389                         }
 390                     }
 391                     if (bNeedContinuation)
 392                     {
 393                         assert(bFound); // ? can this happen temp. during undo?
 394                     }
 395                 }
 396             }
 397             else
 398             {
 399                 assert(!pHt->IsFormatIgnoreStart());
 400                 assert(!pHt->IsFormatIgnoreEnd());
 401             }
 402         }
 403
 404         // 9) nesting portion check
 405         if (pHtThis->IsNesting())
 406         {
 407             for (size_t j = 0; j < i; ++j)
 408             {
 409                 SwTextAttr const * const pOther( m_HintsByStart[j] );
 410                 if (pOther->IsNesting())
 411                 {
 412                     SwComparePosition cmp = ComparePosition(
 413                         pHtThis->GetStart(), *pHtThis->End(),
 414                         pOther->GetStart(), *pOther->End());
 415                     CHECK_ERR( (SwComparePosition::OverlapBefore != cmp) &&
 416                                (SwComparePosition::OverlapBehind != cmp),
 417                         "HintsCheck: overlapping nesting hints!!!" );
 418                 }
 419             }
 420         }
 421
 422         // 10) dummy char check (unfortunately cannot check SwTextNode::m_Text)
 423         if (pHtThis->HasDummyChar())
 424         {
 425             for ( size_t j = 0; j < i; ++j )
 426             {
 427                 SwTextAttr const * const pOther( m_HintsByStart[j] );
 428                 if (pOther->HasDummyChar())
 429                 {
 430                     CHECK_ERR( (pOther->GetStart() != pHtThis->GetStart()),
 431                         "HintsCheck: multiple hints claim same CH_TXTATR!");
 432                 }
 433             }
 434         }
 435     }
 436     return true;
 437 }
 438
 439 #endif      /* DBG_UTIL */
 440
 441 // Resort() is called before every Insert and Delete.
 442 // Various SwTextNode methods modify hints in a way that violates the
 443 // sort order of the m_HintsByStart, m_HintsByEnd arrays, so this method is needed
 444 // to restore the order.
 445
 446 void SwpHints::Resort() const
 447 {
 448     ResortStartMap();
 449     ResortEndMap();
 450     ResortWhichMap();
 451 }
 452
 453 void SwpHints::ResortStartMap() const
 454 {
 455     if (m_StartMapNeedsSortingRange.first != SAL_MAX_INT32)
 456     {
 457         auto & rStartMap = const_cast<SwpHints*>(this)->m_HintsByStart;
 458         if (m_StartMapNeedsSortingRange.first == -1)
 459             std::sort(rStartMap.begin(), rStartMap.end(), CompareSwpHtStart);
 460         else
 461         {
 462             // only need to sort a partial range of the array
 463             auto it1 = std::lower_bound(rStartMap.begin(), rStartMap.end(), m_StartMapNeedsSortingRange.first, CompareSwpHtStartOnly());
 464             auto it2 = std::upper_bound(rStartMap.begin(), rStartMap.end(), m_StartMapNeedsSortingRange.second, CompareSwpHtStartOnly());
 465             std::sort(rStartMap.begin() + std::distance(rStartMap.begin(), it1),
 466                       rStartMap.begin() + std::distance(rStartMap.begin(), it2), CompareSwpHtStart);
 467         }
 468         m_StartMapNeedsSortingRange = { SAL_MAX_INT32, -1 };
 469     }
 470 }
 471
 472 void SwpHints::ResortEndMap() const
 473 {
 474     if (m_EndMapNeedsSortingRange.first != SAL_MAX_INT32)
 475     {
 476         auto & rEndMap = const_cast<SwpHints*>(this)->m_HintsByEnd;
 477         if (m_EndMapNeedsSortingRange.first == -1)
 478             std::sort(rEndMap.begin(), rEndMap.end(), CompareSwpHtEnd());
 479         else
 480         {
 481             // only need to sort a partial range of the array
 482             auto it1 = std::lower_bound(rEndMap.begin(), rEndMap.end(), m_EndMapNeedsSortingRange.first, CompareSwpHtEndOnly());
 483             auto it2 = std::upper_bound(rEndMap.begin(), rEndMap.end(), m_EndMapNeedsSortingRange.second, CompareSwpHtEndOnly());
 484             std::sort(rEndMap.begin() + std::distance(rEndMap.begin(), it1),
 485                       rEndMap.begin() + std::distance(rEndMap.begin(), it2), CompareSwpHtEnd());
 486         }
 487         m_EndMapNeedsSortingRange = { SAL_MAX_INT32, -1 };
 488     }
 489 }
 490
 491 void SwpHints::ResortWhichMap() const
 492 {
 493     if (m_WhichMapNeedsSortingRange.first.first != SAL_MAX_INT32)
 494     {
 495         auto & rWhichStartMap = const_cast<SwpHints*>(this)->m_HintsByWhichAndStart;
 496         if (m_WhichMapNeedsSortingRange.first.first == -1)
 497             std::sort(rWhichStartMap.begin(), rWhichStartMap.end(), CompareSwpHtWhichStart());
 498         else
 499         {
 500             // only need to sort a partial range of the array
 501             auto it1 = std::lower_bound(rWhichStartMap.begin(), rWhichStartMap.end(), m_WhichMapNeedsSortingRange.first, CompareSwpHtWhichStart());
 502             auto it2 = std::upper_bound(rWhichStartMap.begin(), rWhichStartMap.end(), m_WhichMapNeedsSortingRange.second, CompareSwpHtWhichStart());
 503             std::sort(rWhichStartMap.begin() + std::distance(rWhichStartMap.begin(), it1),
 504                       rWhichStartMap.begin() + std::distance(rWhichStartMap.begin(), it2), CompareSwpHtWhichStart());
 505         }
 506         m_WhichMapNeedsSortingRange = { { SAL_MAX_INT32, -1 }, { -1, -1 } };
 507     }
 508 }
 509
 510 size_t SwpHints::GetFirstPosSortedByWhichAndStart( sal_uInt16 nWhich ) const
 511 {
 512     if (m_WhichMapNeedsSortingRange.first.first != SAL_MAX_INT32)
 513         ResortWhichMap();
 514     auto it = std::lower_bound(m_HintsByWhichAndStart.begin(), m_HintsByWhichAndStart.end(), nWhich, CompareSwpHtWhichStart());
 515     if ( it == m_HintsByWhichAndStart.end() )
 516         return SAL_MAX_SIZE;
 517     return it - m_HintsByWhichAndStart.begin();
 518 }
 519
 520 int SwpHints::GetLastPosSortedByEnd( sal_Int32 nEndPos ) const
 521 {
 522     if (m_EndMapNeedsSortingRange.first != SAL_MAX_INT32)
 523         ResortEndMap();
 524     auto it = std::upper_bound(m_HintsByEnd.begin(), m_HintsByEnd.end(), nEndPos, CompareSwpHtEnd());
 525     return it - m_HintsByEnd.begin() - 1;
 526 }
 527
 528 size_t SwpHints::GetIndexOf( const SwTextAttr *pHt ) const
 529 {
 530     if (m_StartMapNeedsSortingRange.first != SAL_MAX_INT32)
 531         ResortStartMap();
 532     auto it = std::lower_bound(m_HintsByStart.begin(), m_HintsByStart.end(), const_cast<SwTextAttr*>(pHt), CompareSwpHtStart);
 533     if ( it == m_HintsByStart.end() || *it != pHt )
 534         return SAL_MAX_SIZE;
 535     return it - m_HintsByStart.begin();
 536 }
 537
 538 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */