/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx
Warning:	line 515, column 9 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name atrftn.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SW_DLLIMPLEMENTATION -D SWUI_DLL_NAME="libswuilo.so" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/source/core/inc -I /home/maarten/src/libreoffice/core/sw/source/filter/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/sw/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx

/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <fmtftn.hxx>

22#include <doc.hxx>
23#include <DocumentContentOperationsManager.hxx>
24#include <IDocumentStylePoolAccess.hxx>
25#include <cntfrm.hxx>
26#include <rootfrm.hxx>
27#include <pagefrm.hxx>
28#include <txtftn.hxx>
29#include <ftnidx.hxx>
30#include <ftninfo.hxx>
31#include <ndtxt.hxx>
32#include <poolfmt.hxx>
33#include <ftnfrm.hxx>
34#include <ndindex.hxx>
35#include <fmtftntx.hxx>
36#include <section.hxx>
37#include <calbck.hxx>
38#include <hints.hxx>
39#include <pam.hxx>
40#include <rtl/ustrbuf.hxx>
41#include <vcl/svapp.hxx>
42#include <unotextrange.hxx>

44namespace {
  /// Get a sorted list of the used footnote reference numbers.
  /// @param[in]  rDoc     The active document.
  /// @param[in]  pExclude A footnote whose reference number should be excluded from the set.
  /// @param[out] rUsedRef The set of used reference numbers.
  /// @param[out] rInvalid  A returned list of all items that had an invalid reference number.
  void lcl_FillUsedFootnoteRefNumbers(SwDoc &rDoc,
                                       SwTextFootnote const *pExclude,
                                       std::set<sal_uInt16> &rUsedRef,
                                       std::vector<SwTextFootnote*> &rInvalid)
  {
      SwFootnoteIdxs& ftnIdxs = rDoc.GetFootnoteIdxs();

      rInvalid.clear();

      for( size_t n = 0; n < ftnIdxs.size(); ++n )
      {
          SwTextFootnote* pTextFootnote = ftnIdxs[ n ];
          if ( pTextFootnote != pExclude )
          {
              if ( USHRT_MAX(32767 *2 +1) == pTextFootnote->GetSeqRefNo() )
              {
                  rInvalid.push_back(pTextFootnote);
              }
              else
              {
                  rUsedRef.insert( pTextFootnote->GetSeqRefNo() );
              }
          }
      }
  }

  /// Check whether a requested reference number is available.
  /// @param[in] rUsedNums Set of used reference numbers.
  /// @param[in] requested The requested reference number.
  /// @returns true if the number is available, false if not.
  bool lcl_IsRefNumAvailable(std::set<sal_uInt16> const &rUsedNums,
                                       sal_uInt16 requested)
  {
      if ( USHRT_MAX(32767 *2 +1) == requested )
          return false;  // Invalid sequence number.
      if ( rUsedNums.count(requested) )
          return false;  // Number already used.
      return true;
  }

  /// Get the first few unused sequential reference numbers.
  /// @param[out] rLowestUnusedNums The lowest unused sequential reference numbers.
  /// @param[in] rUsedNums   The set of used sequential reference numbers.
  /// @param[in] numRequired The number of reference number required.
  void lcl_FillUnusedSeqRefNums(std::vector<sal_uInt16> &rLowestUnusedNums,
                                       const std::set<sal_uInt16> &rUsedNums,
                                       size_t numRequired)
  {
      if (!numRequired)
          return;

      rLowestUnusedNums.reserve(numRequired);
      sal_uInt16 newNum = 0;
      //Start by using numbers from gaps in rUsedNums
      for( const auto& rNum : rUsedNums )
      {
          while ( newNum < rNum )
          {
              rLowestUnusedNums.push_back( newNum++ );
              if ( --numRequired == 0)
                  return;
          }
          newNum++;
      }
      //Filled in all gaps. Fill the rest of the list with new numbers.
      do
      {
          rLowestUnusedNums.push_back( newNum++ );
      }
      while ( --numRequired > 0 );
  }

122}

124SwFormatFootnote::SwFormatFootnote( bool bEndNote )
  : SfxPoolItem( RES_TXTATR_FTN )
  , SwModify()
  , m_pTextAttr(nullptr)
  , m_nNumber(0)
  , m_nNumberRLHidden(0)
  , m_bEndNote(bEndNote)
131{
132}

134bool SwFormatFootnote::operator==( const SfxPoolItem& rAttr ) const
135{
  assert(SfxPoolItem::operator==(rAttr))(static_cast <bool> (SfxPoolItem::operator==(rAttr)) ? void
 (0) : __assert_fail ("SfxPoolItem::operator==(rAttr)", "/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx"
, 136, __extension__ __PRETTY_FUNCTION__));
  return m_nNumber  == static_cast<const SwFormatFootnote&>(rAttr).m_nNumber &&
      //FIXME?
         m_aNumber  == static_cast<const SwFormatFootnote&>(rAttr).m_aNumber &&
         m_bEndNote == static_cast<const SwFormatFootnote&>(rAttr).m_bEndNote;
141}

143SwFormatFootnote* SwFormatFootnote::Clone( SfxItemPool* ) const
144{
  SwFormatFootnote* pNew  = new SwFormatFootnote;
  pNew->m_aNumber = m_aNumber;
  pNew->m_nNumber = m_nNumber;
  pNew->m_nNumberRLHidden = m_nNumberRLHidden;
  pNew->m_bEndNote = m_bEndNote;
  return pNew;
151}

153void SwFormatFootnote::Modify(SfxPoolItem const* pOld, SfxPoolItem const* pNew)
154{
  NotifyClients(pOld, pNew);
  if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which()))
  {   // invalidate cached UNO object
      SetXFootnote(css::uno::Reference<css::text::XFootnote>(nullptr));
  }
160}

162void SwFormatFootnote::InvalidateFootnote()
163{
  SwPtrMsgPoolItem const item(RES_REMOVE_UNO_OBJECT,
          &static_cast<SwModify&>(*this)); // cast to base class (void*)
  NotifyClients(&item, &item);
167}

169void SwFormatFootnote::SetEndNote( bool b )
170{
  if ( b != m_bEndNote )
1
Assuming 'b' is not equal to field 'm_bEndNote'→
2
←
Taking true branch→
  {
      if ( GetTextFootnote() )
3
←
Assuming the condition is true→
4
←
Taking true branch→
      {
          GetTextFootnote()->DelFrames(nullptr);
5
←
Calling 'SwTextFootnote::DelFrames'→
      }
      m_bEndNote = b;
  }
179}

181SwFormatFootnote::~SwFormatFootnote()
182{
183}

185OUString SwFormatFootnote::GetFootnoteText(SwRootFrame const& rLayout) const
186{
  OUStringBuffer buf;
  if( m_pTextAttr->GetStartNode() )
  {
      SwNodeIndex aIdx( *m_pTextAttr->GetStartNode(), 1 );
      SwContentNode* pCNd = aIdx.GetNode().GetTextNode();
      if( !pCNd )
          pCNd = aIdx.GetNodes().GoNext( &aIdx );

      if( pCNd->IsTextNode() ) {
          buf.append(static_cast<SwTextNode*>(pCNd)->GetExpandText(&rLayout));

          ++aIdx;
          while ( !aIdx.GetNode().IsEndNode() ) {
              if ( aIdx.GetNode().IsTextNode() )
              {
                  buf.append("  ");
                  buf.append(aIdx.GetNode().GetTextNode()->GetExpandText(&rLayout));
              }
              ++aIdx;
          }
      }
  }
  return buf.makeStringAndClear();
210}

212/// return the view string of the foot/endnote
213OUString SwFormatFootnote::GetViewNumStr(const SwDoc& rDoc,
      SwRootFrame const*const pLayout, bool bInclStrings) const
215{
  OUString sRet( GetNumStr() );
  if( sRet.isEmpty() )
  {
      // in this case the number is needed, get it via SwDoc's FootnoteInfo
      bool bMakeNum = true;
      const SwSectionNode* pSectNd = m_pTextAttr
                  ? SwUpdFootnoteEndNtAtEnd::FindSectNdWithEndAttr( *m_pTextAttr )
                  : nullptr;
      sal_uInt16 const nNumber(pLayout && pLayout->IsHideRedlines()
              ? GetNumberRLHidden()
              : GetNumber());

      if( pSectNd )
      {
          const SwFormatFootnoteEndAtTextEnd& rFootnoteEnd = static_cast<const SwFormatFootnoteEndAtTextEnd&>(
              pSectNd->GetSection().GetFormat()->GetFormatAttr(
                              IsEndNote() ?
                              static_cast<sal_uInt16>(RES_END_AT_TXTEND) :
                              static_cast<sal_uInt16>(RES_FTN_AT_TXTEND) ) );

          if( FTNEND_ATTXTEND_OWNNUMANDFMT == rFootnoteEnd.GetValue() )
          {
              bMakeNum = false;
              sRet = rFootnoteEnd.GetSwNumType().GetNumStr( nNumber );
              if( bInclStrings )
              {
                  sRet = rFootnoteEnd.GetPrefix() + sRet + rFootnoteEnd.GetSuffix();
              }
          }
      }

      if( bMakeNum )
      {
          const SwEndNoteInfo* pInfo;
          if( IsEndNote() )
              pInfo = &rDoc.GetEndNoteInfo();
          else
              pInfo = &rDoc.GetFootnoteInfo();
          sRet = pInfo->m_aFormat.GetNumStr( nNumber );
          if( bInclStrings )
          {
              sRet = pInfo->GetPrefix() + sRet + pInfo->GetSuffix();
          }
      }
  }
  return sRet;
262}

264uno::Reference<text::XTextRange> SwFormatFootnote::getAnchor(SwDoc& rDoc) const
265{
  SolarMutexGuard aGuard;
  if (!m_pTextAttr)
      return uno::Reference<text::XTextRange>();
  SwPaM aPam(m_pTextAttr->GetTextNode(), m_pTextAttr->GetStart());
  aPam.SetMark();
  ++aPam.GetMark()->nContent;
  const uno::Reference<text::XTextRange> xRet =
      SwXTextRange::CreateXTextRange(rDoc, *aPam.Start(), aPam.End());
  return xRet;
275}

277SwTextFootnote::SwTextFootnote( SwFormatFootnote& rAttr, sal_Int32 nStartPos )
  : SwTextAttr( rAttr, nStartPos )
  , m_pTextNode( nullptr )
  , m_nSeqNo( USHRT_MAX(32767 *2 +1) )
281{
  rAttr.m_pTextAttr = this;
  SetHasDummyChar(true);
284}

286SwTextFootnote::~SwTextFootnote()
287{
  SetStartNode( nullptr );
289}

291void SwTextFootnote::SetStartNode( const SwNodeIndex *pNewNode, bool bDelNode )
292{
  if( pNewNode )
  {
      if ( !m_pStartNode )
      {
          m_pStartNode.reset(new SwNodeIndex(*pNewNode));
      }
      else
      {
          *m_pStartNode = *pNewNode;
      }
  }
  else if ( m_pStartNode )
  {
      // need to do 2 things:
      // 1) unregister footnotes at their pages
      // 2) delete the footnote section in the Inserts of the nodes-array
      SwDoc* pDoc;
      if ( m_pTextNode )
      {
          pDoc = &m_pTextNode->GetDoc();
      }
      else
      {
          //JP 27.01.97: the sw3-Reader creates a StartNode but the
          //             attribute isn't anchored in the TextNode yet.
          //             If it is deleted (e.g. Insert File with footnote
          //             inside fly frame), the content must also be deleted.
          pDoc = &m_pStartNode->GetNodes().GetDoc();
      }

      // If called from ~SwDoc(), must not delete the footnote nodes,
      // and not necessary to delete the footnote frames.
      if( !pDoc->IsInDtor() )
      {
          if( bDelNode )
          {
              // 2) delete the section for the footnote nodes
              // it's possible that the Inserts have already been deleted (how???)
              pDoc->getIDocumentContentOperations().DeleteSection( &m_pStartNode->GetNode() );
          }
          else
              // If the nodes are not deleted, their frames must be removed
              // from the page (deleted), there is nothing else that deletes
              // them (particularly not Undo)
              DelFrames( nullptr );
      }
      m_pStartNode.reset();

      // remove the footnote from the SwDoc's array
      for( size_t n = 0; n < pDoc->GetFootnoteIdxs().size(); ++n )
          if( this == pDoc->GetFootnoteIdxs()[n] )
          {
              pDoc->GetFootnoteIdxs().erase( pDoc->GetFootnoteIdxs().begin() + n );
              // if necessary, update following footnotes
              if( !pDoc->IsInDtor() && n < pDoc->GetFootnoteIdxs().size() )
              {
                  SwNodeIndex aTmp( pDoc->GetFootnoteIdxs()[n]->GetTextNode() );
                  pDoc->GetFootnoteIdxs().UpdateFootnote( aTmp );
              }
              break;
          }
  }
355}

357void SwTextFootnote::SetNumber(const sal_uInt16 nNewNum,
      sal_uInt16 const nNumberRLHidden, const OUString &sNumStr)
359{
  SwFormatFootnote& rFootnote = const_cast<SwFormatFootnote&>(GetFootnote());

  rFootnote.m_aNumber = sNumStr;
  if ( sNumStr.isEmpty() )
  {
      rFootnote.m_nNumber = nNewNum;
      rFootnote.m_nNumberRLHidden = nNumberRLHidden;
  }
  InvalidateNumberInLayout();
369}

371void SwTextFootnote::InvalidateNumberInLayout()
372{
  assert(m_pTextNode)(static_cast <bool> (m_pTextNode) ? void (0) : __assert_fail
 ("m_pTextNode", "/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx"
, 373, __extension__ __PRETTY_FUNCTION__));
  SwFormatFootnote const& rFootnote(GetFootnote());
  SwNodes &rNodes = m_pTextNode->GetDoc().GetNodes();
  m_pTextNode->ModifyNotification( nullptr, &rFootnote );
  if ( m_pStartNode )
  {
      // must iterate over all TextNodes because of footnotes on other pages
      sal_uLong nSttIdx = m_pStartNode->GetIndex() + 1;
      sal_uLong nEndIdx = m_pStartNode->GetNode().EndOfSectionIndex();
      for( ; nSttIdx < nEndIdx; ++nSttIdx )
      {
          SwNode* pNd;
          if( ( pNd = rNodes[ nSttIdx ] )->IsTextNode() )
              static_cast<SwTextNode*>(pNd)->ModifyNotification( nullptr, &rFootnote );
      }
  }
389}

391void SwTextFootnote::CopyFootnote(
  SwTextFootnote & rDest,
  SwTextNode & rDestNode ) const
394{
  if (m_pStartNode && !rDest.GetStartNode())
  {
      // dest missing node section? create it here!
      // (happens in SwTextNode::CopyText if pDest == this)
      rDest.MakeNewTextSection( rDestNode.GetNodes() );
  }
  if (m_pStartNode && rDest.GetStartNode())
  {
      // footnotes not necessarily in same document!
      SwDoc& rDstDoc = rDestNode.GetDoc();
      SwNodes &rDstNodes = rDstDoc.GetNodes();

      // copy only the content of the section
      SwNodeRange aRg( *m_pStartNode, 1,
                  *m_pStartNode->GetNode().EndOfSectionNode() );

      // insert at the end of rDest, i.e., the nodes are appended.
      // nDestLen contains number of ContentNodes in rDest _before_ copy.
      SwNodeIndex aStart( *(rDest.GetStartNode()) );
      SwNodeIndex aEnd( *aStart.GetNode().EndOfSectionNode() );
      sal_uLong  nDestLen = aEnd.GetIndex() - aStart.GetIndex() - 1;

      m_pTextNode->GetDoc().GetDocumentContentOperationsManager().CopyWithFlyInFly(aRg, aEnd);

      // in case the destination section was not empty, delete the old nodes
      // before:   Src: SxxxE,  Dst: SnE
      // now:      Src: SxxxE,  Dst: SnxxxE
      // after:    Src: SxxxE,  Dst: SxxxE
      ++aStart;
      rDstNodes.Delete( aStart, nDestLen );
  }

  // also copy user defined number string
  if( !GetFootnote().m_aNumber.isEmpty() )
  {
      const_cast<SwFormatFootnote &>(rDest.GetFootnote()).m_aNumber = GetFootnote().m_aNumber;
  }
432}

434/// create a new nodes-array section for the footnote
435void SwTextFootnote::MakeNewTextSection( SwNodes& rNodes )
436{
  if ( m_pStartNode )
      return;

  // set the footnote style on the SwTextNode
  SwTextFormatColl *pFormatColl;
  const SwEndNoteInfo* pInfo;
  sal_uInt16 nPoolId;

  if( GetFootnote().IsEndNote() )
  {
      pInfo = &rNodes.GetDoc().GetEndNoteInfo();
      nPoolId = RES_POOLCOLL_ENDNOTE;
  }
  else
  {
      pInfo = &rNodes.GetDoc().GetFootnoteInfo();
      nPoolId = RES_POOLCOLL_FOOTNOTE;
  }

  pFormatColl = pInfo->GetFootnoteTextColl();
  if( nullptr == pFormatColl )
      pFormatColl = rNodes.GetDoc().getIDocumentStylePoolAccess().GetTextCollFromPool( nPoolId );

  SwStartNode* pSttNd = rNodes.MakeTextSection( SwNodeIndex( rNodes.GetEndOfInserts() ),
                                      SwFootnoteStartNode, pFormatColl );
  m_pStartNode.reset(new SwNodeIndex(*pSttNd));
463}

465void SwTextFootnote::DelFrames(SwRootFrame const*const pRoot)
466{
  // delete the FootnoteFrames from the pages
  OSL_ENSURE( m_pTextNode, "SwTextFootnote: where is my TextNode?" )do { if (true && (!(m_pTextNode))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx"
 ":" "468" ": "), "%s", "SwTextFootnote: where is my TextNode?"
); } } while (false);
6
←
Assuming field 'm_pTextNode' is non-null→
7
←
Taking false branch→
8
←
Loop condition is false.  Exiting loop→
  if ( !m_pTextNode8.1
Field 'm_pTextNode' is non-null
1
Field 'm_pTextNode' is non-null
1
Field 'm_pTextNode' is non-null
1
Field 'm_pTextNode' is non-null
1
Field 'm_pTextNode' is non-null
 )
9
←
Taking false branch→
      return;

  bool bFrameFnd = false;
  {
      SwIterator<SwContentFrame, SwTextNode, sw::IteratorMode::UnwrapMulti> aIter(*m_pTextNode);
      for( SwContentFrame* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
10
←
Loop condition is false. Execution continues on line 322→
      {
          if( pRoot != pFnd->getRootFrame() && pRoot )
              continue;
          SwPageFrame* pPage = pFnd->FindPageFrame();
          if( pPage )
          {
              // note: we have found the correct frame only if the footnote
              // was actually removed; in case this is called from
              // SwTextFrame::DestroyImpl(), then that frame isn't connected
              // to SwPageFrame any more, and RemoveFootnote on any follow
              // must not prevent the fall-back to the !bFrameFnd code.
              bFrameFnd = pPage->RemoveFootnote(pFnd, this);
          }
      }
  }
  //JP 13.05.97: if the layout is deleted before the footnotes are deleted,
  //             try to delete the footnote's frames by another way
  if ( bFrameFnd10.1
'bFrameFnd' is false
1
'bFrameFnd' is false
1
'bFrameFnd' is false
1
'bFrameFnd' is false
1
'bFrameFnd' is false
 || !m_pStartNode )
11
←
Calling 'unique_ptr::operator bool'→
15
←
Returning from 'unique_ptr::operator bool'→
16
←
Taking false branch→
      return;

  SwNodeIndex aIdx( *m_pStartNode );
  SwContentNode* pCNd = m_pTextNode->GetNodes().GoNext( &aIdx );
  if( !pCNd )
17
←
Assuming 'pCNd' is non-null→
18
←
Taking false branch→
      return;

  SwIterator<SwContentFrame, SwContentNode, sw::IteratorMode::UnwrapMulti> aIter(*pCNd);
19
←
Calling constructor for 'SwIterator<SwContentFrame, SwContentNode, sw::IteratorMode::UnwrapMulti>'→
34
←
Returning from constructor for 'SwIterator<SwContentFrame, SwContentNode, sw::IteratorMode::UnwrapMulti>'→
  for( SwContentFrame* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
35
←
Calling 'SwIterator::First'→
39
←
Returning from 'SwIterator::First'→
40
←
Loop condition is true.  Entering loop body→
  {
      if( pRoot != pFnd->getRootFrame() && pRoot )
41
←
Assuming the condition is false→
          continue;
      SwPageFrame* pPage = pFnd->FindPageFrame();

      SwFrame *pFrame = pFnd->GetUpper();
42
←
'pFrame' initialized here→
      while ( pFrame && !pFrame->IsFootnoteFrame() )
43
←
Assuming 'pFrame' is null→
          pFrame = pFrame->GetUpper();

      SwFootnoteFrame *pFootnote = static_cast<SwFootnoteFrame*>(pFrame);
44
←
'pFootnote' initialized to a null pointer value→
      while ( pFootnote44.1
'pFootnote' is null
1
'pFootnote' is null
1
'pFootnote' is null
1
'pFootnote' is null
1
'pFootnote' is null
 && pFootnote->GetMaster() )
          pFootnote = pFootnote->GetMaster();
      OSL_ENSURE( pFootnote->GetAttr() == this, "Footnote mismatch error." )do { if (true && (!(pFootnote->GetAttr() == this))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/core/txtnode/atrftn.cxx"
 ":" "515" ": "), "%s", "Footnote mismatch error."); } } while
 (false);
45
←
Called C++ object pointer is null

      while ( pFootnote )
      {
          SwFootnoteFrame *pFoll = pFootnote->GetFollow();
          pFootnote->Cut();
          SwFrame::DestroyFrame(pFootnote);
          pFootnote = pFoll;
      }

      // #i20556# During hiding of a section, the connection
      // to the layout is already lost. pPage may be 0:
      if ( pPage )
          pPage->UpdateFootnoteNum();
  }
530}

532/// Set the sequence number for the current footnote.
533/// @returns The new sequence number or USHRT_MAX if invalid.
534void SwTextFootnote::SetSeqRefNo()
535{
  if( !m_pTextNode )
      return;

  SwDoc& rDoc = m_pTextNode->GetDoc();
  if( rDoc.IsInReading() )
      return;

  std::set<sal_uInt16> aUsedNums;
  std::vector<SwTextFootnote*> badRefNums;
  ::lcl_FillUsedFootnoteRefNumbers(rDoc, this, aUsedNums, badRefNums);
  if ( ::lcl_IsRefNumAvailable(aUsedNums, m_nSeqNo) )
      return;
  std::vector<sal_uInt16> unused;
  ::lcl_FillUnusedSeqRefNums(unused, aUsedNums, 1);
  m_nSeqNo = unused[0];
551}

553/// Set a unique sequential reference number for every footnote in the document.
554/// @param[in] rDoc The document to be processed.
555void SwTextFootnote::SetUniqueSeqRefNo( SwDoc& rDoc )
556{
  std::set<sal_uInt16> aUsedNums;
  std::vector<SwTextFootnote*> badRefNums;
  ::lcl_FillUsedFootnoteRefNumbers(rDoc, nullptr, aUsedNums, badRefNums);
  std::vector<sal_uInt16> aUnused;
  ::lcl_FillUnusedSeqRefNums(aUnused, aUsedNums, badRefNums.size());

  for (size_t i = 0; i < badRefNums.size(); ++i)
  {
      badRefNums[i]->m_nSeqNo = aUnused[i];
  }
567}

569void SwTextFootnote::CheckCondColl()
570{
571//FEATURE::CONDCOLL
  if( GetStartNode() )
      static_cast<SwStartNode&>(GetStartNode()->GetNode()).CheckSectionCondColl();
574//FEATURE::CONDCOLL
575}

577/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/unique_ptr.h

→

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>
40#if __cplusplus201703L > 201703L
41# include <compare>
42# include <ostream>
43#endif

45namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
46{
47_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

54#if _GLIBCXX_USE_DEPRECATED1
55#pragma GCC diagnostic push
56#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
58#pragma GCC diagnostic pop
59#endif

/// Primary template of default_delete, used by unique_ptr for single objects
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for objects of another type, `_Up`,
     * only if `_Up*` is convertible to `_Tp*`.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up*, _Tp*>>>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls `delete __ptr`
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length

/// Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of `_Tp`.
     *
     * Conversions from types derived from `_Tp` are not allowed because
     * it is undefined to `delete[]` an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls `delete[] __ptr`
    template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
 static_assert(sizeof(_Tp)>0,
	"can't delete pointer to incomplete type");
 delete [] __ptr;
}
  };

/// @cond undocumented

// Manages the pointer and deleter of a unique_ptr
template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    static_assert( !is_rvalue_reference<_Dp>::value,
     "unique_ptr's deleter type must be a function object type"
     " or an lvalue reference type" );

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
    : _M_t(std::move(__u._M_t))
    { __u._M_ptr() = nullptr; }

    __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
    {
reset(__u.release());
_M_deleter() = std::forward<_Dp>(__u._M_deleter());
return *this;
    }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

    void reset(pointer __p) noexcept
    {
const pointer __old_p = _M_ptr();
_M_ptr() = __p;
if (__old_p)
 _M_deleter()(__old_p);
    }

    pointer release() noexcept
    {
pointer __p = _M_ptr();
_M_ptr() = nullptr;
return __p;
    }

    void
    swap(__uniq_ptr_impl& __rhs) noexcept
    {
using std::swap;
swap(this->_M_ptr(), __rhs._M_ptr());
swap(this->_M_deleter(), __rhs._M_deleter());
    }

  private:
    tuple<pointer, _Dp> _M_t;
  };

// Defines move construction + assignment as either defaulted or deleted.
template <typename _Tp, typename _Dp,
   bool = is_move_constructible<_Dp>::value,
   bool = is_move_assignable<_Dp>::value>
  struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };
/// @endcond

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <typename _Up>
using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

  private:
    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
 __not_<is_array<_Up>>
      >;

  public:
    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_copy_constructible<_Del>>>
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a (non-reference) deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_move_constructible<_Del>>>
unique_ptr(pointer __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(__p, std::move(__d))
{ }

    template<typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type>
unique_ptr(pointer,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

344#if _GLIBCXX_USE_DEPRECATED1
345#pragma GCC diagnostic push
346#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
351#pragma GCC diagnostic pop
352#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(std::move(__ptr));
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr& operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }
12
←
Assuming the condition is false→
13
←
'?' condition is false→
14
←
Returning the value 1, which participates in a condition later→

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
_M_t.reset(std::move(__p));
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _UPtr = unique_ptr<_Up, _Ep>,
      typename _UP_pointer = typename _UPtr::pointer,
      typename _UP_element_type = typename _UPtr::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<_UP_pointer, _UP_element_type*>,
        is_convertible<_UP_element_type(*)[], element_type(*)[]>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_copy_constructible<_Del>>>
    unique_ptr(_Up __p, const deleter_type& __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_move_constructible<_Del>>>
unique_ptr(_Up __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ }

    template<typename _Up, typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type,
      typename = _Require<__safe_conversion_raw<_Up>>>
unique_ptr(_Up,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
      { }

    template<typename _Up, typename _Ep, typename = _Require<
      __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    { _M_t.reset(std::move(__p)); }

    void reset(nullptr_t = nullptr) noexcept
    { reset(pointer()); }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

/// @relates unique_ptr @{

/// Swap overload for unique_ptr
template<typename _Tp, typename _Dp>
  inline
732#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
735#else
  void
737#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

742#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
747#endif

/// Equality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

763#ifndef __cpp_lib_three_way_comparison
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

/// Inequality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }
789#endif // three way comparison

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

888#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
  requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
		       typename unique_ptr<_Up, _Ep>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
	       typename unique_ptr<_Up, _Ep>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
  { return compare_three_way()(__x.get(), __y.get()); }

template<typename _Tp, typename _Dp>
  requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
    return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
  }
908#endif
// @} relates unique_ptr

/// @cond undocumented
template<typename _Up, typename _Ptr = typename _Up::pointer,
  bool = __poison_hash<_Ptr>::__enable_hash_call>
  struct __uniq_ptr_hash
915#if ! _GLIBCXX_INLINE_VERSION0
  : private __poison_hash<_Ptr>
917#endif
  {
    size_t
    operator()(const _Up& __u) const
    noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
    { return hash<_Ptr>()(__u.get()); }
  };

template<typename _Up, typename _Ptr>
  struct __uniq_ptr_hash<_Up, _Ptr, false>
  : private __poison_hash<_Ptr>
  { };
/// @endcond

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
    public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
  { };

938#if __cplusplus201703L >= 201402L
/// @relates unique_ptr @{
940#define __cpp_lib_make_unique201304 201304

/// @cond undocumented

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// @endcond

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
// @} relates unique_ptr
975#endif // C++14

977#if __cplusplus201703L > 201703L && __cpp_concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2948. unique_ptr does not define operator<< for stream output
/// Stream output operator for unique_ptr
template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
  inline basic_ostream<_CharT, _Traits>&
  operator<<(basic_ostream<_CharT, _Traits>& __os,
      const unique_ptr<_Tp, _Dp>& __p)
  requires requires { __os << __p.get(); }
  {
    __os << __p.get();
    return __os;
  }
990#endif // C++20

// @} group pointer_abstractions

994#if __cplusplus201703L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // unique_ptr into a variant.
  template<typename _Tp, typename _Del>
    struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
    : std::true_type
    { };
}  // namespace __detail::__variant
1006#endif // C++17

1008_GLIBCXX_END_NAMESPACE_VERSION
1009} // namespace

1011#endif /* _UNIQUE_PTR_H */

←

/home/maarten/src/libreoffice/core/sw/inc/calbck.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_SW_INC_CALBCK_HXX
21#define INCLUDED_SW_INC_CALBCK_HXX

23#include <cassert>

25#include <svl/hint.hxx>
26#include <svl/broadcast.hxx>
27#include <svl/poolitem.hxx>
28#include "swdllapi.h"
29#include "ring.hxx"
30#include <type_traits>
31#include <vector>
32#include <memory>

34class SwModify;
35class SfxPoolItem;

37/*
  SwModify and SwClient cooperate in propagating attribute changes.
  If an attribute changes, the change is notified to all dependent
  formats and other interested objects, e.g. Nodes. The clients will detect
  if the change affects them. It could be that the changed attribute is
  overruled in the receiving object so that its change does not become
  effective or that the receiver is not interested in the particular attribute
  in general (though probably in other attributes of the SwModify object they
  are registered in).
  As SwModify objects are derived from SwClient, they can create a chain of SwClient
  objects where changes can get propagated through.
  Each SwClient can be registered at only one SwModify object, while each SwModify
  object is connected to a list of SwClient objects. If an object derived from SwClient
  wants to get notifications from more than one SwModify object, it must create additional
  SwClient objects. The SwDepend class allows to handle their notifications in the same
  notification callback as it forwards the Modify() calls it receives to a "master"
  SwClient implementation.
  The SwIterator class allows to iterate over the SwClient objects registered at an
  SwModify. For historical reasons its ability to use TypeInfo to restrict this iteration
  to objects of a particular type created a lot of code that misuses SwClient-SwModify
  relationships that basically should be used only for Modify/Notify callbacks.
  This is still subject to refactoring.
*/

61namespace sw
62{
  class ClientIteratorBase;
  struct LegacyModifyHint final: SfxHint
  {
      LegacyModifyHint(const SfxPoolItem* pOld, const SfxPoolItem* pNew) : m_pOld(pOld), m_pNew(pNew) {};
      sal_uInt16 GetWhich() const { return m_pOld ? m_pOld->Which() : m_pNew ? m_pNew->Which() : 0; };
      virtual ~LegacyModifyHint() override;
      const SfxPoolItem* m_pOld;
      const SfxPoolItem* m_pNew;
  };
  struct ModifyChangedHint final: SfxHint
  {
      ModifyChangedHint(const SwModify* pNew) : m_pNew(pNew) {};
      virtual ~ModifyChangedHint() override;
      const SwModify* m_pNew;
  };
  // Observer pattern using svl implementation
  // use this instead of SwClient/SwModify wherever possible
  // In writer layout, this might not always be possible,
  // but for listeners outside of it (e.g. unocore) this should be used.
  // The only "magic" signal this class issues is a ModifyChangedHint
  // proclaiming its death. It does NOT however provide a new SwModify for
  // listeners to switch to like the old SwModify/SwClient did, as that leads
  // to madness.
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) BroadcasterMixin {
      SvtBroadcaster m_aNotifier;
      public:
          BroadcasterMixin() = default;
          BroadcasterMixin(BroadcasterMixin const &) = default;
          BroadcasterMixin& operator=(const BroadcasterMixin&)
          {
              return *this; // Listeners are never copied or moved.
          }
          SvtBroadcaster& GetNotifier() { return m_aNotifier; }
  };
  /// refactoring out the same of the more sane SwClient functionality
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) WriterListener
  {
      friend class ::SwModify;
      friend class ::sw::ClientIteratorBase;
      private:
          WriterListener* m_pLeft;
          WriterListener* m_pRight; ///< double-linked list of other clients

          WriterListener(WriterListener const&) = delete;
          WriterListener& operator=(WriterListener const&) = delete;

      protected:
          WriterListener()
              : m_pLeft(nullptr), m_pRight(nullptr)
          {}
          virtual ~WriterListener() COVERITY_NOEXCEPT_FALSE {}
          virtual void SwClientNotify( const SwModify&, const SfxHint& rHint) =0;
      public:
          bool IsLast() const { return !m_pLeft && !m_pRight; }
  };
  enum class IteratorMode { Exact, UnwrapMulti };
119}

121// SwClient
122class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwClient : public ::sw::WriterListener
123{
  // avoids making the details of the linked list and the callback method public
  friend class SwModify;
  friend class sw::ClientIteratorBase;
  template<typename E, typename S, sw::IteratorMode> friend class SwIterator;

  SwModify *m_pRegisteredIn;        ///< event source

131protected:
  // single argument ctors shall be explicit.
  inline explicit SwClient( SwModify* pToRegisterIn );

  // write access to pRegisteredIn shall be granted only to the object itself (protected access)
  SwModify* GetRegisteredInNonConst() const { return m_pRegisteredIn; }

138public:
  SwClient() : m_pRegisteredIn(nullptr) {}
  SwClient(SwClient&&) noexcept;
  virtual ~SwClient() override;
  // callbacks received from SwModify (friend class - so these methods can be private)
  // should be called only from SwModify the client is registered in
  // mba: IMHO this method should be pure virtual
  // DO NOT USE IN NEW CODE! use SwClientNotify instead.
  virtual void Modify(const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue);
  // when overriding this, you MUST call SwClient::SwClientModify() in the override!
  virtual void SwClientNotify(const SwModify&, const SfxHint& rHint) override;

  // in case an SwModify object is destroyed that itself is registered in another SwModify,
  // its SwClient objects can decide to get registered to the latter instead by calling this method
  std::unique_ptr<sw::ModifyChangedHint> CheckRegistration( const SfxPoolItem* pOldValue );

  // controlled access to Modify method
  // mba: this is still considered a hack and it should be fixed; the name makes grep-ing easier
  virtual void ModifyNotification( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue ) { Modify ( pOldValue, pNewValue ); }
  void SwClientNotifyCall( const SwModify& rModify, const SfxHint& rHint ) { SwClientNotify( rModify, rHint ); }

  const SwModify* GetRegisteredIn() const { return m_pRegisteredIn; }
  SwModify* GetRegisteredIn() { return m_pRegisteredIn; }
  void EndListeningAll();
  void StartListeningToSameModifyAs(const SwClient&);


  // get information about attribute
  virtual bool GetInfo( SfxPoolItem& ) const { return true; }
167};


170// SwModify

172// class has a doubly linked list for dependencies
173class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwModify: public SwClient
174{
  friend class sw::ClientIteratorBase;
  template<typename E, typename S, sw::IteratorMode> friend class SwIterator;
  sw::WriterListener* m_pWriterListeners;                // the start of the linked list of clients
  bool m_bModifyLocked : 1;         // don't broadcast changes now
  bool m_bLockClientList : 1;       // may be set when this instance notifies its clients
  bool m_bInCache   : 1;
  bool m_bInSwFntCache : 1;

  // mba: IMHO this method should be pure virtual
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  virtual void Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) override
      { NotifyClients( pOld, pNew ); };

  SwModify(SwModify const &) = delete;
  SwModify &operator =(const SwModify&) = delete;
190public:
  SwModify()
      : SwClient(), m_pWriterListeners(nullptr), m_bModifyLocked(false), m_bLockClientList(false), m_bInCache(false), m_bInSwFntCache(false)
  {}

  // broadcasting: send notifications to all clients
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  void NotifyClients( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue );
  // the same, but without setting m_bModifyLocked or checking for any of the flags
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  void ModifyBroadcast( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue)
      { CallSwClientNotify( sw::LegacyModifyHint{ pOldValue, pNewValue } ); };

  // a more universal broadcasting mechanism
  virtual void CallSwClientNotify( const SfxHint& rHint ) const;

  virtual ~SwModify() override;

  void Add(SwClient *pDepend);
  SwClient* Remove(SwClient *pDepend);
  bool HasWriterListeners() const { return m_pWriterListeners; }

  // get information about attribute
  virtual bool GetInfo( SfxPoolItem& ) const override;

  void LockModify()                   { m_bModifyLocked = true;  }
  void UnlockModify()                 { m_bModifyLocked = false; }
  void SetInCache( bool bNew )        { m_bInCache = bNew;       }
  void SetInSwFntCache( bool bNew )   { m_bInSwFntCache = bNew;  }
  void SetInDocDTOR();
  bool IsModifyLocked() const     { return m_bModifyLocked;  }
  bool IsInCache()      const     { return m_bInCache;       }
  bool IsInSwFntCache() const     { return m_bInSwFntCache;  }

  void CheckCaching( const sal_uInt16 nWhich );
  bool HasOnlyOneListener() const { return m_pWriterListeners && m_pWriterListeners->IsLast(); }
226};

228template<typename TElementType, typename TSource, sw::IteratorMode eMode> class SwIterator;

230namespace sw
231{
  // this class is part of the migration: it still forwards the "old"
  // SwModify events and announces them both to the old SwClients still
  // registered and also to the new SvtListeners.
  // Still: in the long run the SwClient/SwModify interface should not be
  // used anymore, in which case a BroadcasterMixin should be enough instead
  // then.
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) BroadcastingModify : public SwModify, public BroadcasterMixin {
      public:
          virtual void CallSwClientNotify(const SfxHint& rHint) const override;
  };
  // this should be hidden but sadly SwIterator template needs it...
  class ListenerEntry final : public SwClient
  {
  private:
      template<typename E, typename S, sw::IteratorMode> friend class ::SwIterator;
      SwClient *m_pToTell;

  public:
      ListenerEntry(SwClient *const pTellHim, SwModify *const pDepend)
          : SwClient(pDepend), m_pToTell(pTellHim)
      {}
      ListenerEntry(ListenerEntry const &) = delete;
      ListenerEntry& operator=(ListenerEntry const&) = delete;
      ListenerEntry(ListenerEntry&& other) noexcept
          : SwClient(std::move(other))
          , m_pToTell(other.m_pToTell)
      { }
      ListenerEntry& operator=(ListenerEntry&& other) noexcept
      {
          m_pToTell = other.m_pToTell;
          other.GetRegisteredIn()->Add(this);
          other.EndListeningAll();
          return *this;
      }

      /** get Client information */
      virtual bool GetInfo( SfxPoolItem& rInfo) const override;
  private:
      virtual void Modify(const SfxPoolItem* pOldValue, const SfxPoolItem *pNewValue) override;
      virtual void SwClientNotify(const SwModify& rModify, const SfxHint& rHint) override;
  };

  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) WriterMultiListener final
  {
      SwClient& m_rToTell;
      std::vector<ListenerEntry> m_vDepends;
      public:
          WriterMultiListener(SwClient& rToTell);
          WriterMultiListener& operator=(WriterMultiListener const&) = delete; // MSVC2015 workaround
          WriterMultiListener(WriterMultiListener const&) = delete; // MSVC2015 workaround
          ~WriterMultiListener();
          void StartListening(SwModify* pDepend);
          void EndListening(SwModify* pDepend);
          bool IsListeningTo(const SwModify* const pDepend) const;
          void EndListeningAll();
  };
  class ClientIteratorBase : public sw::Ring< ::sw::ClientIteratorBase >
  {
          friend SwClient* SwModify::Remove(SwClient*);
          friend void SwModify::Add(SwClient*);
      protected:
          const SwModify& m_rRoot;
          // the current object in an iteration
          WriterListener* m_pCurrent;
          // in case the current object is already removed, the next object in the list
          // is marked down to become the current object in the next step
          // this is necessary because iteration requires access to members of the current object
          WriterListener* m_pPosition;
          static SW_DLLPUBLIC__attribute__ ((visibility("default"))) ClientIteratorBase* s_pClientIters;

          ClientIteratorBase( const SwModify& rModify )
              : m_rRoot(rModify)
          {
              MoveTo(s_pClientIters);
21
←
Calling 'Ring::MoveTo'→
32
←
Returning from 'Ring::MoveTo'→
              s_pClientIters = this;
              m_pCurrent = m_pPosition = m_rRoot.m_pWriterListeners;
          }
          WriterListener* GetLeftOfPos() { return m_pPosition->m_pLeft; }
          WriterListener* GetRightOfPos() { return m_pPosition->m_pRight; }
          WriterListener* GoStart()
          {
              m_pPosition = m_rRoot.m_pWriterListeners;
              if(m_pPosition)
                  while( m_pPosition->m_pLeft )
                      m_pPosition = m_pPosition->m_pLeft;
              m_pCurrent = m_pPosition;
              return m_pCurrent;
          }
          ~ClientIteratorBase() override
          {
              assert(s_pClientIters)(static_cast <bool> (s_pClientIters) ? void (0) : __assert_fail
 ("s_pClientIters", "/home/maarten/src/libreoffice/core/sw/inc/calbck.hxx"
, 322, __extension__ __PRETTY_FUNCTION__));
              if(s_pClientIters == this)
                  s_pClientIters = unique() ? nullptr : GetNextInRing();
              MoveTo(nullptr);
          }
          // return "true" if an object was removed from a client chain in iteration
          // adding objects to a client chain in iteration is forbidden
          // SwModify::Add() asserts this
          bool IsChanged() const { return m_pPosition != m_pCurrent; }
          // ensures the iterator to point at a current client
          WriterListener* Sync() { m_pCurrent = m_pPosition; return m_pCurrent; }
  };
334}

336template<typename TElementType, typename TSource,
      sw::IteratorMode eMode = sw::IteratorMode::Exact> class SwIterator final
  : private sw::ClientIteratorBase
339{
  //static_assert(!std::is_base_of<SwPageDesc,TSource>::value, "SwPageDesc as TSource is deprecated.");
  static_assert(std::is_base_of<SwClient,TElementType>::value, "TElementType needs to be derived from SwClient.");
  static_assert(std::is_base_of<SwModify,TSource>::value, "TSource needs to be derived from SwModify.");
343public:
  SwIterator( const TSource& rSrc ) : sw::ClientIteratorBase(rSrc) {}
20
←
Calling constructor for 'ClientIteratorBase'→
33
←
Returning from constructor for 'ClientIteratorBase'→
  TElementType* First()
  {
      GoStart();
      if(!m_pPosition)
36
←
Assuming field 'm_pPosition' is non-null, which participates in a condition later→
37
←
Taking false branch→
          return nullptr;
      m_pCurrent = nullptr;
      return Next();
38
←
Returning pointer, which participates in a condition later→
  }
  TElementType* Next()
  {
      if(!IsChanged())
          m_pPosition = GetRightOfPos();
      sw::WriterListener *pCurrent(m_pPosition);
      while (m_pPosition)
      {
          if (eMode == sw::IteratorMode::UnwrapMulti)
          {
              if (auto const pLE = dynamic_cast<sw::ListenerEntry const*>(m_pPosition))
              {
                  pCurrent = pLE->m_pToTell;
              }
          }
          if (dynamic_cast<const TElementType *>(pCurrent) == nullptr)
          {
              m_pPosition = GetRightOfPos();
              pCurrent = m_pPosition;
          }
          else
              break;
      }
      Sync();
      return static_cast<TElementType*>(pCurrent);
  }
  using sw::ClientIteratorBase::IsChanged;
379};

381template< typename TSource > class SwIterator<SwClient, TSource> final : private sw::ClientIteratorBase
382{
  static_assert(std::is_base_of<SwModify,TSource>::value, "TSource needs to be derived from SwModify");
384public:
  SwIterator( const TSource& rSrc ) : sw::ClientIteratorBase(rSrc) {}
  SwClient* First()
      { return static_cast<SwClient*>(GoStart()); }
  SwClient* Next()
  {
      if(!IsChanged())
          m_pPosition = GetRightOfPos();
      return static_cast<SwClient*>(Sync());
  }
  using sw::ClientIteratorBase::IsChanged;
395};

397SwClient::SwClient( SwModify* pToRegisterIn )
  : m_pRegisteredIn( nullptr )
399{
  if(pToRegisterIn)
      pToRegisterIn->Add(this);
402}

404#endif

406/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/sw/inc/ring.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
19#ifndef INCLUDED_SW_INC_RING_HXX
20#define INCLUDED_SW_INC_RING_HXX

22#include <utility>
23#include <sal/types.h>
24#include <iterator>
25#include <type_traits>
26#include <boost/iterator/iterator_facade.hpp>
27#include <boost/intrusive/circular_list_algorithms.hpp>

29namespace sw
30{
  template <typename value_type> class RingContainer;
  template <typename value_type> class RingIterator;
  /**
   * An intrusive container class double linking the contained nodes
   * @example sw/qa/core/uwriter.cxx
   */
  template <typename value_type>
  class SAL_WARN_UNUSED__attribute__((warn_unused)) Ring
  {
      public:
          typedef typename std::add_const<value_type>::type const_value_type;
          typedef RingContainer<value_type> ring_container;
          typedef RingContainer<const_value_type> const_ring_container;
          virtual ~Ring() COVERITY_NOEXCEPT_FALSE
              { unlink(); };
          /** algo::unlink is buggy! don't call it directly! */
          void unlink()
          {
              algo::unlink(this);
23
←
Calling 'circular_list_algorithms::unlink'→
28
←
Returning from 'circular_list_algorithms::unlink'→
              m_pNext = this; // don't leave pointers to old list behind!
              m_pPrev = this;
          }
          /**
           * Removes this item from its current ring container and adds it to
           * another ring container. If the item was not alone in the original
           * ring container, the other items in the ring will stay in the old
           * ring container.
           * Note: the newly created item will be inserted just before item pDestRing.
           * @param pDestRing the container to add this item to
           */
          void MoveTo( value_type* pDestRing );
          /** @return a stl-like container with begin()/end() for iteration */
          ring_container GetRingContainer();
          /** @return a stl-like container with begin()/end() for const iteration */
          const_ring_container GetRingContainer() const;

      protected:
          /**
           * Creates a new item in a ring container all by itself.
           * Note: Ring instances can newer be outside a container. At most, they
           * are alone in one.
           */
          Ring()
              : m_pNext(this)
              , m_pPrev(this)
              { }
          /**
           * Creates a new item and add it to an existing ring container.
           * Note: the newly created item will be inserted just before item pRing.
           * @param pRing ring container to add the created item to
           */
          Ring( value_type* pRing );
          /** @return the next item in the ring container */
          value_type* GetNextInRing()
              { return static_cast<value_type *>(m_pNext); }
          /** @return the previous item in the ring container */
          value_type* GetPrevInRing()
              { return static_cast<value_type *>(m_pPrev); }
          /** @return the next item in the ring container */
          const_value_type* GetNextInRing() const
              { return static_cast<value_type *>(m_pNext); }
          /** @return the previous item in the ring container */
          const_value_type* GetPrevInRing() const
              { return static_cast<value_type *>(m_pPrev); }
          /** @return true if and only if this item is alone in its ring */
          bool unique() const
              { return algo::unique(static_cast< const_value_type* >(this)); }

      private:
          /** internal implementation class -- not for external use */
          struct Ring_node_traits
          {
              typedef Ring node;
              typedef Ring* node_ptr;
              typedef const Ring* const_node_ptr;
              static node_ptr get_next(const_node_ptr n) { return const_cast<node_ptr>(n)->m_pNext; };
              static void set_next(node_ptr n, node_ptr next) { n->m_pNext = next; };
              static node_ptr get_previous(const_node_ptr n) { return const_cast<node_ptr>(n)->m_pPrev; };
              static void set_previous(node_ptr n, node_ptr previous) { n->m_pPrev = previous; };
          };
          friend ring_container;
          friend const_ring_container;
          friend typename ring_container::iterator;
          friend typename ring_container::const_iterator;
          friend typename const_ring_container::iterator;
          friend typename const_ring_container::const_iterator;
          friend class boost::iterator_core_access;
          typedef boost::intrusive::circular_list_algorithms<Ring_node_traits> algo;
          Ring* m_pNext;
          Ring* m_pPrev;
  };

  template <typename value_type>
  inline Ring<value_type>::Ring( value_type* pObj )
      : m_pNext(this)
      , m_pPrev(this)
  {
      if( pObj )
      {
          algo::link_before(pObj, this);
      }
  }

  template <typename value_type>
  inline void Ring<value_type>::MoveTo(value_type* pDestRing)
  {
      value_type* pThis = static_cast< value_type* >(this);
      unlink();
22
←
Calling 'Ring::unlink'→
29
←
Returning from 'Ring::unlink'→
      // insert into "new"
      if (pDestRing)
30
←
Assuming 'pDestRing' is null→
31
←
Taking false branch→
      {
          algo::link_before(pDestRing, pThis);
      }
  }

  /**
   * helper class that provides Svalue_typeL-style container iteration to the ring
   */
  template <typename value_type>
  class SAL_WARN_UNUSED__attribute__((warn_unused)) RingContainer final
  {
      private:
          /** the item in the ring where iteration starts */
          value_type* m_pStart;
          typedef typename std::remove_const<value_type>::type nonconst_value_type;

      public:
          RingContainer( value_type* pRing ) : m_pStart(pRing) {};
          typedef RingIterator<value_type> iterator;
          typedef RingIterator<const value_type> const_iterator;
          /**
           * iterator access
           * @code
           * for(SwPaM& rCurrentPaM : pPaM->GetRingContainer())
           *     do_stuff(rCurrentPaM); // this gets called on every SwPaM in the same ring as pPaM
           * @endcode
           */
          iterator begin();
          iterator end();
          const_iterator begin() const;
          const_iterator end() const;
          /** @return the number of elements in the container */
          size_t size() const
              { return std::distance(begin(), end()); }
          /**
           * Merges two ring containers. All item from both ring containers will
           * be in the same ring container in the end.
           * Note: The items of this ring container will be inserted just before
           * item pDestRing
           * @param pDestRing the container to merge this container with
           */
          void merge( RingContainer< value_type > aDestRing )
          {
              // first check that we aren't merged already, swapping would
              // actually un-merge in this case!
              assert(m_pStart->m_pPrev != aDestRing.m_pStart)(static_cast <bool> (m_pStart->m_pPrev != aDestRing.
m_pStart) ? void (0) : __assert_fail ("m_pStart->m_pPrev != aDestRing.m_pStart"
, "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx", 186, __extension__
 __PRETTY_FUNCTION__));
              assert(m_pStart != aDestRing.m_pStart->m_pPrev)(static_cast <bool> (m_pStart != aDestRing.m_pStart->
m_pPrev) ? void (0) : __assert_fail ("m_pStart != aDestRing.m_pStart->m_pPrev"
, "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx", 187, __extension__
 __PRETTY_FUNCTION__));
              std::swap(m_pStart->m_pPrev->m_pNext, aDestRing.m_pStart->m_pPrev->m_pNext);
              std::swap(m_pStart->m_pPrev, aDestRing.m_pStart->m_pPrev);
          }
  };

  template <typename value_type>
  class RingIterator final : public boost::iterator_facade<
        RingIterator<value_type>
      , value_type
      , boost::forward_traversal_tag
      >
  {
      private:
          typedef typename std::remove_const<value_type>::type nonconst_value_type;
      public:
          RingIterator()
              : m_pCurrent(nullptr)
              , m_pStart(nullptr)
          {}
          explicit RingIterator(nonconst_value_type* pRing, bool bStart = true)
              : m_pCurrent(nullptr)
              , m_pStart(pRing)
          {
              if(!bStart)
                  m_pCurrent = m_pStart;
          }

      private:
          friend class boost::iterator_core_access;
          void increment()
              { m_pCurrent = m_pCurrent ? m_pCurrent->GetNextInRing() : m_pStart->GetNextInRing(); }
          bool equal(RingIterator const& other) const
          {
              // we never want to compare iterators from
              // different rings or starting points
              assert(m_pStart == other.m_pStart)(static_cast <bool> (m_pStart == other.m_pStart) ? void
 (0) : __assert_fail ("m_pStart == other.m_pStart", "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx"
, 223, __extension__ __PRETTY_FUNCTION__));
              return m_pCurrent == other.m_pCurrent;
          }
          value_type& dereference() const
              { return m_pCurrent ? *m_pCurrent : * m_pStart; }
          /**
           * value_type is:
           * - pointing to the current item in the iteration in general
           * - nullptr if on the first item (begin())
           * - m_pStart when beyond the last item (end())
           */
          nonconst_value_type* m_pCurrent;
          /** the first item of the iteration */
          nonconst_value_type* m_pStart;
  };

  template <typename value_type>
  inline typename Ring<value_type>::ring_container Ring<value_type>::GetRingContainer()
      { return Ring<value_type>::ring_container(static_cast< value_type* >(this)); };

  template <typename value_type>
  inline typename Ring<value_type>::const_ring_container Ring<value_type>::GetRingContainer() const
      { return Ring<value_type>::const_ring_container(static_cast< const_value_type* >(this)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::iterator RingContainer<value_type>::begin()
      { return RingContainer<value_type>::iterator(const_cast< nonconst_value_type* >(m_pStart)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::iterator RingContainer<value_type>::end()
      { return RingContainer<value_type>::iterator(const_cast< nonconst_value_type* >(m_pStart), false); };

  template <typename value_type>
  inline typename RingContainer<value_type>::const_iterator RingContainer<value_type>::begin() const
      { return RingContainer<value_type>::const_iterator(const_cast< nonconst_value_type* >(m_pStart)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::const_iterator RingContainer<value_type>::end() const
      { return RingContainer<value_type>::const_iterator(const_cast< nonconst_value_type* >(m_pStart), false); };
262}
263#endif

265/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost/boost/intrusive/circular_list_algorithms.hpp

1/////////////////////////////////////////////////////////////////////////////
2//
3// (C) Copyright Olaf Krzikalla 2004-2006.
4// (C) Copyright Ion Gaztanaga  2006-2014
5//
6// Distributed under the Boost Software License, Version 1.0.
7//    (See accompanying file LICENSE_1_0.txt or copy at
8//          http://www.boost.org/LICENSE_1_0.txt)
9//
10// See http://www.boost.org/libs/intrusive for documentation.
11//
12/////////////////////////////////////////////////////////////////////////////

14#ifndef BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP
15#define BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP

17#include <boost/intrusive/detail/config_begin.hpp>
18#include <boost/intrusive/intrusive_fwd.hpp>
19#include <boost/intrusive/detail/algo_type.hpp>
20#include <boost/core/no_exceptions_support.hpp>
21#include <cstddef>

23#if defined(BOOST_HAS_PRAGMA_ONCE)
24#  pragma once
25#endif

27namespace boost {
28namespace intrusive {

30//! circular_list_algorithms provides basic algorithms to manipulate nodes
31//! forming a circular doubly linked list. An empty circular list is formed by a node
32//! whose pointers point to itself.
33//!
34//! circular_list_algorithms is configured with a NodeTraits class, which encapsulates the
35//! information about the node to be manipulated. NodeTraits must support the
36//! following interface:
37//!
38//! <b>Typedefs</b>:
39//!
40//! <tt>node</tt>: The type of the node that forms the circular list
41//!
42//! <tt>node_ptr</tt>: A pointer to a node
43//!
44//! <tt>const_node_ptr</tt>: A pointer to a const node
45//!
46//! <b>Static functions</b>:
47//!
48//! <tt>static node_ptr get_previous(const_node_ptr n);</tt>
49//!
50//! <tt>static void set_previous(node_ptr n, node_ptr prev);</tt>
51//!
52//! <tt>static node_ptr get_next(const_node_ptr n);</tt>
53//!
54//! <tt>static void set_next(node_ptr n, node_ptr next);</tt>
55template<class NodeTraits>
56class circular_list_algorithms
57{
 public:
 typedef typename NodeTraits::node            node;
 typedef typename NodeTraits::node_ptr        node_ptr;
 typedef typename NodeTraits::const_node_ptr  const_node_ptr;
 typedef NodeTraits                           node_traits;

 //! <b>Effects</b>: Constructs an non-used list element, so that
 //! inited(this_node) == true
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void init(node_ptr this_node)
 {
    const node_ptr null_node = node_ptr();
    NodeTraits::set_next(this_node, null_node);
    NodeTraits::set_previous(this_node, null_node);
 }

 //! <b>Effects</b>: Returns true is "this_node" is in a non-used state
 //! as if it was initialized by the "init" function.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static bool inited(const const_node_ptr &this_node)
 {  return !NodeTraits::get_next(this_node); }

 //! <b>Effects</b>: Constructs an empty list, making this_node the only
 //!   node of the circular list:
 //!  <tt>NodeTraits::get_next(this_node) == NodeTraits::get_previous(this_node)
 //!  == this_node</tt>.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void init_header(node_ptr this_node)
 {
    NodeTraits::set_next(this_node, this_node);
    NodeTraits::set_previous(this_node, this_node);
 }


 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list:
 //!  <tt>return NodeTraits::get_next(this_node) == this_node</tt>
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static bool unique(const const_node_ptr &this_node)
 {
    node_ptr next = NodeTraits::get_next(this_node);
    return !next || next == this_node;
 }

 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Returns the number of nodes in a circular list. If the circular list
 //!  is empty, returns 1.
 //!
 //! <b>Complexity</b>: Linear
 //!
 //! <b>Throws</b>: Nothing.
 static std::size_t count(const const_node_ptr &this_node)
 {
    std::size_t result = 0;
    const_node_ptr p = this_node;
    do{
       p = NodeTraits::get_next(p);
       ++result;
    }while (p != this_node);
    return result;
 }

 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Unlinks the node from the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static node_ptr unlink(node_ptr this_node)
 {
    node_ptr next(NodeTraits::get_next(this_node));
    node_ptr prev(NodeTraits::get_previous(this_node));
    NodeTraits::set_next(prev, next);
24
←
Calling 'Ring_node_traits::set_next'→
25
←
Returning from 'Ring_node_traits::set_next'→
    NodeTraits::set_previous(next, prev);
26
←
Calling 'Ring_node_traits::set_previous'→
27
←
Returning from 'Ring_node_traits::set_previous'→
    return next;
 }

 //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range.
 //!
 //! <b>Effects</b>: Unlinks the node [b, e) from the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void unlink(node_ptr b, node_ptr e)
 {
    if (b != e) {
       node_ptr prevb(NodeTraits::get_previous(b));
       NodeTraits::set_previous(e, prevb);
       NodeTraits::set_next(prevb, e);
    }
 }

 //! <b>Requires</b>: nxt_node must be a node of a circular list.
 //!
 //! <b>Effects</b>: Links this_node before nxt_node in the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void link_before(node_ptr nxt_node, node_ptr this_node)
 {
    node_ptr prev(NodeTraits::get_previous(nxt_node));
    NodeTraits::set_previous(this_node, prev);
    NodeTraits::set_next(this_node, nxt_node);
    //nxt_node might be an alias for prev->next_
    //so use it before NodeTraits::set_next(prev, ...)
    //is called and the reference changes its value
    NodeTraits::set_previous(nxt_node, this_node);
    NodeTraits::set_next(prev, this_node);
 }

 //! <b>Requires</b>: prev_node must be a node of a circular list.
 //!
 //! <b>Effects</b>: Links this_node after prev_node in the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void link_after(node_ptr prev_node, node_ptr this_node)
 {
    node_ptr next(NodeTraits::get_next(prev_node));
    NodeTraits::set_previous(this_node, prev_node);
    NodeTraits::set_next(this_node, next);
    //prev_node might be an alias for next->next_
    //so use it before update it before NodeTraits::set_previous(next, ...)
    //is called and the reference changes it's value
    NodeTraits::set_next(prev_node, this_node);
    NodeTraits::set_previous(next, this_node);
 }

 //! <b>Requires</b>: this_node and other_node must be nodes inserted
 //!  in circular lists or be empty circular lists.
 //!
 //! <b>Effects</b>: Swaps the position of the nodes: this_node is inserted in
 //!   other_nodes position in the second circular list and the other_node is inserted
 //!   in this_node's position in the first circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void swap_nodes(node_ptr this_node, node_ptr other_node)
 {
    if (other_node == this_node)
       return;
    bool this_inited  = inited(this_node);
    bool other_inited = inited(other_node);
    if(this_inited){
       init_header(this_node);
    }
    if(other_inited){
       init_header(other_node);
    }

    node_ptr next_this(NodeTraits::get_next(this_node));
    node_ptr prev_this(NodeTraits::get_previous(this_node));
    node_ptr next_other(NodeTraits::get_next(other_node));
    node_ptr prev_other(NodeTraits::get_previous(other_node));
    //these first two swaps must happen before the other two
    swap_prev(next_this, next_other);
    swap_next(prev_this, prev_other);
    swap_next(this_node, other_node);
    swap_prev(this_node, other_node);

    if(this_inited){
       init(other_node);
    }
    if(other_inited){
       init(this_node);
    }
 }

 //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range.
 //!   and p must be a node of a different circular list or may not be an iterator in
 //    [b, e).
 //!
 //! <b>Effects</b>: Removes the nodes from [b, e) range from their circular list and inserts
 //!   them before p in p's circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void transfer(node_ptr p, node_ptr b, node_ptr e)
 {
    if (b != e) {
       node_ptr prev_p(NodeTraits::get_previous(p));
       node_ptr prev_b(NodeTraits::get_previous(b));
       node_ptr prev_e(NodeTraits::get_previous(e));
       NodeTraits::set_next(prev_e, p);
       NodeTraits::set_previous(p, prev_e);
       NodeTraits::set_next(prev_b, e);
       NodeTraits::set_previous(e, prev_b);
       NodeTraits::set_next(prev_p, b);
       NodeTraits::set_previous(b, prev_p);
    }
 }

 //! <b>Requires</b>: i must a node of a circular list
 //!   and p must be a node of a different circular list.
 //!
 //! <b>Effects</b>: Removes the node i from its circular list and inserts
 //!   it before p in p's circular list.
 //!   If p == i or p == NodeTraits::get_next(i), this function is a null operation.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void transfer(node_ptr p, node_ptr i)
 {
    node_ptr n(NodeTraits::get_next(i));
    if(n != p && i != p){
       node_ptr prev_p(NodeTraits::get_previous(p));
       node_ptr prev_i(NodeTraits::get_previous(i));
       NodeTraits::set_next(prev_p, i);
       NodeTraits::set_previous(i, prev_p);
       NodeTraits::set_next(i, p);
       NodeTraits::set_previous(p, i);
       NodeTraits::set_previous(n, prev_i);
       NodeTraits::set_next(prev_i, n);

    }
 }

 //! <b>Effects</b>: Reverses the order of elements in the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: This function is linear time.
 static void reverse(node_ptr p)
 {
    node_ptr f(NodeTraits::get_next(p));
    node_ptr i(NodeTraits::get_next(f)), e(p);

    while(i != e) {
       node_ptr n = i;
       i = NodeTraits::get_next(i);
       transfer(f, n, i);
       f = n;
    }
 }

 //! <b>Effects</b>: Moves the node p n positions towards the end of the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of moved positions.
 static void move_backwards(node_ptr p, std::size_t n)
 {
    //Null shift, nothing to do
    if(!n) return;
    node_ptr first  = NodeTraits::get_next(p);
    //size() == 0 or 1, nothing to do
    if(first == NodeTraits::get_previous(p)) return;
    unlink(p);
    //Now get the new first node
    while(n--){
       first = NodeTraits::get_next(first);
    }
    link_before(first, p);
 }

 //! <b>Effects</b>: Moves the node p n positions towards the beginning of the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of moved positions.
 static void move_forward(node_ptr p, std::size_t n)
 {
    //Null shift, nothing to do
    if(!n)   return;
    node_ptr last  = NodeTraits::get_previous(p);
    //size() == 0 or 1, nothing to do
    if(last == NodeTraits::get_next(p))   return;

    unlink(p);
    //Now get the new last node
    while(n--){
       last = NodeTraits::get_previous(last);
    }
    link_after(last, p);
 }

 //! <b>Requires</b>: f and l must be in a circular list.
 //!
 //! <b>Effects</b>: Returns the number of nodes in the range [f, l).
 //!
 //! <b>Complexity</b>: Linear
 //!
 //! <b>Throws</b>: Nothing.
 static std::size_t distance(const const_node_ptr &f, const const_node_ptr &l)
 {
    const_node_ptr i(f);
    std::size_t result = 0;
    while(i != l){
       i = NodeTraits::get_next(i);
       ++result;
    }
    return result;
 }

 struct stable_partition_info
 {
    std::size_t num_1st_partition;
    std::size_t num_2nd_partition;
    node_ptr    beg_2st_partition;
 };

 template<class Pred>
 static void stable_partition(node_ptr beg, node_ptr end, Pred pred, stable_partition_info &info)
 {
    node_ptr bcur = node_traits::get_previous(beg);
    node_ptr cur  = beg;
    node_ptr new_f = end;

    std::size_t num1 = 0, num2 = 0;
    while(cur != end){
       if(pred(cur)){
          ++num1;
          bcur = cur;
          cur  = node_traits::get_next(cur);
       }
       else{
          ++num2;
          node_ptr last_to_remove = bcur;
          new_f = cur;
          bcur = cur;
          cur  = node_traits::get_next(cur);
          BOOST_TRY{ try{
             //Main loop
             while(cur != end){
                if(pred(cur)){ //Might throw
                   ++num1;
                   //Process current node
                   node_traits::set_next    (last_to_remove, cur);
                   node_traits::set_previous(cur, last_to_remove);
                   last_to_remove = cur;
                   node_ptr nxt = node_traits::get_next(cur);
                   node_traits::set_next    (bcur, nxt);
                   node_traits::set_previous(nxt, bcur);
                   cur = nxt;
                }
                else{
                   ++num2;
                   bcur = cur;
                   cur  = node_traits::get_next(cur);
                }
             }
          }
          BOOST_CATCH(...)catch(...){
             node_traits::set_next    (last_to_remove, new_f);
             node_traits::set_previous(new_f, last_to_remove);
             BOOST_RETHROWthrow;;
          }
          BOOST_CATCH_END}
          node_traits::set_next(last_to_remove, new_f);
          node_traits::set_previous(new_f, last_to_remove);
          break;
       }
    }
    info.num_1st_partition = num1;
    info.num_2nd_partition = num2;
    info.beg_2st_partition = new_f;
 }

 private:
 BOOST_INTRUSIVE_FORCEINLINEinline static void swap_prev(node_ptr this_node, node_ptr other_node)
 {
    node_ptr temp(NodeTraits::get_previous(this_node));
    NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
    NodeTraits::set_previous(other_node, temp);
 }

 BOOST_INTRUSIVE_FORCEINLINEinline static void swap_next(node_ptr this_node, node_ptr other_node)
 {
    node_ptr temp(NodeTraits::get_next(this_node));
    NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
    NodeTraits::set_next(other_node, temp);
 }
451};

453/// @cond

455template<class NodeTraits>
456struct get_algo<CircularListAlgorithms, NodeTraits>
457{
 typedef circular_list_algorithms<NodeTraits> type;
459};

461/// @endcond

463} //namespace intrusive
464} //namespace boost

466#include <boost/intrusive/detail/config_end.hpp>

468#endif //BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP