/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 113, column 13 Use of memory after it is freed

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 FrameControlsManager.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/uibase/docvw/FrameControlsManager.cxx

/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 */
9 
10#include <edtwin.hxx>
11#include <FrameControlsManager.hxx>
12#include <HeaderFooterWin.hxx>
13#include <PageBreakWin.hxx>
14#include <UnfloatTableButton.hxx>
15#include <pagefrm.hxx>
16#include <flyfrm.hxx>
17#include <viewopt.hxx>
18#include <view.hxx>
19#include <wrtsh.hxx>
20#include <txtfrm.hxx>
21#include <OutlineContentVisibilityWin.hxx>
22#include <ndtxt.hxx>
23#include <IDocumentOutlineNodes.hxx>
24 
25using namespace std;
26 
27SwFrameControlsManager::SwFrameControlsManager( SwEditWin* pEditWin ) :
28    m_pEditWin( pEditWin ),
29    m_aControls( )
30{
31}
32 
33SwFrameControlsManager::~SwFrameControlsManager()
34{
35}
36 
37void SwFrameControlsManager::dispose()
38{
39    m_aControls.clear();
40    m_aTextNodeContentFrameMap.clear();
41}
42 
43SwFrameControlPtr SwFrameControlsManager::GetControl( FrameControlType eType, const SwFrame* pFrame )
44{
45    SwFrameControlPtrMap& rControls = m_aControls[eType];
46 
47    SwFrameControlPtrMap::iterator aIt = rControls.find(pFrame);
48 
49    if (aIt != rControls.end())
50        return aIt->second;
51 
52    return SwFrameControlPtr();
53}
54 
55void SwFrameControlsManager::RemoveControls( const SwFrame* pFrame )
56{
57    for ( auto& rEntry : m_aControls )
58    {
59        SwFrameControlPtrMap& rMap = rEntry.second;
60        rMap.erase(pFrame);
61    }
62}
63 
64void SwFrameControlsManager::RemoveControlsByType( FrameControlType eType, const SwFrame* pFrame )
65{
66    SwFrameControlPtrMap& rMap = m_aControls[eType];
67    rMap.erase(pFrame);
68}
69 
70void SwFrameControlsManager::HideControls( FrameControlType eType )
71{
72    for ( const auto& rCtrl : m_aControls[eType] )
73        rCtrl.second->ShowAll( false );
74}
75 
76void SwFrameControlsManager::SetReadonlyControls( bool bReadonly )
77{
78    for ( auto& rEntry : m_aControls )
79        for ( auto& rCtrl : rEntry.second )
80            rCtrl.second->SetReadonly( bReadonly );
81}
82 
83void SwFrameControlsManager::SetHeaderFooterControl( const SwPageFrame* pPageFrame, FrameControlType eType, Point aOffset )
84{
85    assert( eType == FrameControlType::Header || eType == FrameControlType::Footer )(static_cast <bool> (eType == FrameControlType::Header ||
 eType == FrameControlType::Footer) ? void (0) : __assert_fail
 ("eType == FrameControlType::Header || eType == FrameControlType::Footer"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 85, __extension__ __PRETTY_FUNCTION__));
86 
87    // Check if we already have the control
88    SwFrameControlPtr pControl;
89    const bool bHeader = ( eType == FrameControlType::Header );
90 
91    SwFrameControlPtrMap& rControls = m_aControls[eType];
92 
93    SwFrameControlPtrMap::iterator lb = rControls.lower_bound(pPageFrame);
94    if (lb != rControls.end() && !(rControls.key_comp()(pPageFrame, lb->first)))
95        pControl = lb->second;
96    else
97    {
98        SwFrameControlPtr pNewControl =
99                std::make_shared<SwFrameControl>( VclPtr<SwHeaderFooterWin>::Create(
100                                        m_pEditWin, pPageFrame, bHeader ).get() );
101        const SwViewOption* pViewOpt = m_pEditWin->GetView().GetWrtShell().GetViewOptions();
102        pNewControl->SetReadonly( pViewOpt->IsReadonly() );
103        rControls.insert(lb, make_pair(pPageFrame, pNewControl));
104        pControl.swap( pNewControl );
105    }
106 
107    tools::Rectangle aPageRect = m_pEditWin->LogicToPixel( pPageFrame->getFrameArea().SVRect() );
108 
109    SwHeaderFooterWin* pWin = dynamic_cast<SwHeaderFooterWin *>(pControl->GetWindow());
110    assert( pWin != nullptr)(static_cast <bool> (pWin != nullptr) ? void (0) : __assert_fail
 ("pWin != nullptr", "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 110, __extension__ __PRETTY_FUNCTION__)) ;
111    assert( pWin->IsHeader() == bHeader )(static_cast <bool> (pWin->IsHeader() == bHeader) ? void
 (0) : __assert_fail ("pWin->IsHeader() == bHeader", "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 111, __extension__ __PRETTY_FUNCTION__));
112    pWin->SetOffset( aOffset, aPageRect.Left(), aPageRect.Right() );
113 
114    if (!pWin->IsVisible())
115        pControl->ShowAll( true );
116}
117 
118void SwFrameControlsManager::SetPageBreakControl( const SwPageFrame* pPageFrame )
119{
120    // Check if we already have the control
121    SwFrameControlPtr pControl;
122 
123    SwFrameControlPtrMap& rControls = m_aControls[FrameControlType::PageBreak];
124 
125    SwFrameControlPtrMap::iterator lb = rControls.lower_bound(pPageFrame);
126    if (lb != rControls.end() && !(rControls.key_comp()(pPageFrame, lb->first)))
1
Taking false branch→
127        pControl = lb->second;
128    else
129    {
130        SwFrameControlPtr pNewControl = std::make_shared<SwFrameControl>(
5
←
Calling 'make_shared<SwFrameControl, SwPageBreakWin *>'→
30
←
Returning; memory was released via 1st parameter→
131                VclPtr<SwPageBreakWin>::Create( m_pEditWin, pPageFrame ).get() );
2
←
Calling 'VclPtr::Create'→
4
←
Returned allocated memory→
31
←
Calling implicit destructor for 'VclPtr<SwPageBreakWin>'→
32
←
Calling '~Reference'→
132        const SwViewOption* pViewOpt = m_pEditWin->GetView().GetWrtShell().GetViewOptions();
133        pNewControl->SetReadonly( pViewOpt->IsReadonly() );
134 
135        rControls.insert(lb, make_pair(pPageFrame, pNewControl));
136 
137        pControl.swap( pNewControl );
138    }
139 
140    SwPageBreakWin* pWin = dynamic_cast<SwPageBreakWin *>(pControl->GetWindow());
141    assert (pWin != nullptr)(static_cast <bool> (pWin != nullptr) ? void (0) : __assert_fail
 ("pWin != nullptr", "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 141, __extension__ __PRETTY_FUNCTION__));
142    pWin->UpdatePosition();
143    if (!pWin->IsVisible())
144        pControl->ShowAll( true );
145}
146 
147void SwFrameControlsManager::SetUnfloatTableButton( const SwFlyFrame* pFlyFrame, bool bShow, Point aTopRightPixel )
148{
149    if(pFlyFrame == nullptr)
150        return;
151 
152    // Check if we already have the control
153    SwFrameControlPtr pControl;
154 
155    SwFrameControlPtrMap& rControls = m_aControls[FrameControlType::FloatingTable];
156 
157    SwFrameControlPtrMap::iterator lb = rControls.lower_bound(pFlyFrame);
158    if (lb != rControls.end() && !(rControls.key_comp()(pFlyFrame, lb->first)))
159        pControl = lb->second;
160    else if (!bShow) // Do not create the control when it's not shown
161        return;
162    else
163    {
164        SwFrameControlPtr pNewControl = std::make_shared<SwFrameControl>(
165                VclPtr<UnfloatTableButton>::Create( m_pEditWin, pFlyFrame ).get() );
166        const SwViewOption* pViewOpt = m_pEditWin->GetView().GetWrtShell().GetViewOptions();
167        pNewControl->SetReadonly( pViewOpt->IsReadonly() );
168 
169        rControls.insert(lb, make_pair(pFlyFrame, pNewControl));
170 
171        pControl.swap( pNewControl );
172    }
173 
174    UnfloatTableButton* pButton = dynamic_cast<UnfloatTableButton*>(pControl->GetWindow());
175    assert(pButton != nullptr)(static_cast <bool> (pButton != nullptr) ? void (0) : __assert_fail
 ("pButton != nullptr", "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 175, __extension__ __PRETTY_FUNCTION__));
176    pButton->SetOffset(aTopRightPixel);
177    pControl->ShowAll( bShow );
178}
179 
180SwFrameMenuButtonBase::SwFrameMenuButtonBase( SwEditWin* pEditWin, const SwFrame* pFrame ) :
181    MenuButton( pEditWin, WB_DIALOGCONTROL ),
182    m_pEditWin( pEditWin ),
183    m_pFrame( pFrame )
184{
185}
186 
187void SwFrameControlsManager::SetOutlineContentVisibilityButtons()
188{
189    // remove entries with outline node keys that are not in the outline nodes list
190    IDocumentOutlineNodes::tSortedOutlineNodeList aOutlineNodes;
191    m_pEditWin->GetView().GetWrtShell().getIDocumentOutlineNodesAccess()->getOutlineNodes(aOutlineNodes);
192    std::map<const SwTextNode*, const SwContentFrame*>::iterator it = m_aTextNodeContentFrameMap.begin();
193    while(it != m_aTextNodeContentFrameMap.end())
194    {
195        const SwNode* pNd = it->first;
196        IDocumentOutlineNodes::tSortedOutlineNodeList::iterator i = std::find(aOutlineNodes.begin(), aOutlineNodes.end(), pNd);
197        if (i == aOutlineNodes.end())
198        {
199            RemoveControlsByType(FrameControlType::Outline, it->second);
200            it = m_aTextNodeContentFrameMap.erase(it);
201        }
202        else
203            it++;
204    }
205    for (SwNode* pNd : m_pEditWin->GetView().GetWrtShell().GetNodes().GetOutLineNds())
206    {
207        bool bOutlineContentVisibleAttr = true;
208        pNd->GetTextNode()->GetAttrOutlineContentVisible(bOutlineContentVisibleAttr);
209        if (!bOutlineContentVisibleAttr)
210            SetOutlineContentVisibilityButton(pNd->GetTextNode());
211    }
212}
213 
214void SwFrameControlsManager::SetOutlineContentVisibilityButton(const SwTextNode* pTextNd)
215{
216    const SwContentFrame* pContentFrame = pTextNd->getLayoutFrame(nullptr);
217 
218    // has node frame changed or been deleted
219    std::map<const SwTextNode*, const SwContentFrame*>::iterator iter = m_aTextNodeContentFrameMap.find(pTextNd);
220    if (iter != m_aTextNodeContentFrameMap.end())
221    {
222        const SwContentFrame* pFrameWas = iter->second;
223        if (pContentFrame != pFrameWas)
224        {
225            // frame does not match frame in map for node
226            RemoveControlsByType(FrameControlType::Outline, pFrameWas);
227            m_aTextNodeContentFrameMap.erase(iter);
228        }
229    }
230    if (pContentFrame && !pContentFrame->IsInDtor())
231    {
232        // frame is not being destroyed and isn't in map
233        m_aTextNodeContentFrameMap.insert(make_pair(pTextNd, pContentFrame));
234    }
235    else
236    {
237        if (pContentFrame)
238        {
239            // frame is being destroyed
240            RemoveControlsByType(FrameControlType::Outline, pContentFrame);
241        }
242        return;
243    }
244 
245    // Check if we already have the control
246    SwFrameControlPtr pControl;
247 
248    SwFrameControlPtrMap& rControls = m_aControls[FrameControlType::Outline];
249 
250    SwFrameControlPtrMap::iterator lb = rControls.lower_bound(pContentFrame);
251    if (lb != rControls.end() && !(rControls.key_comp()(pContentFrame, lb->first)))
252    {
253        pControl = lb->second;
254    }
255    else
256    {
257        SwFrameControlPtr pNewControl =
258                std::make_shared<SwFrameControl>(VclPtr<SwOutlineContentVisibilityWin>::Create(
259                                        m_pEditWin, pContentFrame).get());
260        rControls.insert(lb, make_pair(pContentFrame, pNewControl));
261        pControl.swap(pNewControl);
262    }
263 
264    SwOutlineContentVisibilityWin* pWin = dynamic_cast<SwOutlineContentVisibilityWin *>(pControl->GetWindow());
265    assert(pWin != nullptr)(static_cast <bool> (pWin != nullptr) ? void (0) : __assert_fail
 ("pWin != nullptr", "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 265, __extension__ __PRETTY_FUNCTION__)) ;
266    pWin->Set();
267 
268    if (pWin->GetSymbol() == SymbolType::ARROW_RIGHT)
269    {
270        // show expand button immediately
271        pWin->Show();
272        // outline content might not be folded, this happens on undo, outline moves, and folded outline content reveals
273        SwOutlineNodes::size_type nPos;
274        SwOutlineNodes rOutlineNds = m_pEditWin->GetView().GetWrtShell().GetNodes().GetOutLineNds();
275        if (rOutlineNds.Seek_Entry(const_cast<SwTextNode*>(pTextNd), &nPos))
276        {
277            // don't toggle if next node is an outline node or end node
278            SwNodeIndex aIdx(*pTextNd, 1);
279            if (!(aIdx.GetNode().IsEndNode() || ((nPos + 1 < rOutlineNds.size()) && &aIdx.GetNode() == rOutlineNds[nPos +1]))
280                    && aIdx.GetNode().IsContentNode() && aIdx.GetNode().GetContentNode()->getLayoutFrame(nullptr))
281            {
282                m_pEditWin->GetView().GetWrtShell().ToggleOutlineContentVisibility(nPos, true); // force fold
283            }
284        }
285    }
286    else if (!pWin->IsVisible() && pWin->GetSymbol() == SymbolType::ARROW_DOWN)
287        pWin->ShowAll(true);
288}
289 
290const SwPageFrame* SwFrameMenuButtonBase::GetPageFrame() const
291{
292    if (m_pFrame->IsPageFrame())
293        return static_cast<const SwPageFrame*>( m_pFrame );
294 
295    if (m_pFrame->IsFlyFrame())
296        return static_cast<const SwFlyFrame*>(m_pFrame)->GetAnchorFrame()->FindPageFrame();
297 
298    return m_pFrame->FindPageFrame();
299}
300 
301void SwFrameMenuButtonBase::dispose()
302{
303    m_pEditWin.clear();
304    m_pFrame = nullptr;
305    MenuButton::dispose();
306}
307 
308SwFrameControl::SwFrameControl( const VclPtr<vcl::Window> &pWindow )
309{
310    assert(static_cast<bool>(pWindow))(static_cast <bool> (static_cast<bool>(pWindow)) ?
 void (0) : __assert_fail ("static_cast<bool>(pWindow)"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/docvw/FrameControlsManager.cxx"
, 310, __extension__ __PRETTY_FUNCTION__));
311    mxWindow.reset( pWindow );
312    mpIFace = dynamic_cast<ISwFrameControl *>( pWindow.get() );
313}
314 
315SwFrameControl::~SwFrameControl()
316{
317    mpIFace = nullptr;
318    mxWindow.disposeAndClear();
319}
320 
321ISwFrameControl::~ISwFrameControl()
322{
323}
324 
325/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.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_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
3
←
Memory is allocated→
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
      if (aTmp.get()) {
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

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

←

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

→

1// shared_ptr and weak_ptr implementation -*- C++ -*-

3// Copyright (C) 2007-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// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

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

49#ifndef _SHARED_PTR_H1
50#define _SHARED_PTR_H1 1

52#include <bits/shared_ptr_base.h>

54namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
55{
56_GLIBCXX_BEGIN_NAMESPACE_VERSION

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

// 20.7.2.2.11 shared_ptr I/O

/// Write the stored pointer to an ostream.
/// @relates shared_ptr
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
  inline std::basic_ostream<_Ch, _Tr>&
  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
      const __shared_ptr<_Tp, _Lp>& __p)
  {
    __os << __p.get();
    return __os;
  }

template<typename _Del, typename _Tp, _Lock_policy _Lp>
  inline _Del*
  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
  {
80#if __cpp_rtti199711L
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
82#else
    return 0;
84#endif
  }

/// 20.7.2.2.10 shared_ptr get_deleter

/// If `__p` has a deleter of type `_Del`, return a pointer to it.
/// @relates shared_ptr
template<typename _Del, typename _Tp>
  inline _Del*
  get_deleter(const shared_ptr<_Tp>& __p) noexcept
  {
95#if __cpp_rtti199711L
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
97#else
    return 0;
99#endif
  }

/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 * A `shared_ptr` object is either empty or _owns_ a pointer passed
 * to the constructor. Copies of a `shared_ptr` share ownership of
 * the same pointer. When the last `shared_ptr` that owns the pointer
 * is destroyed or reset, the owned pointer is freed (either by `delete`
 * or by invoking a custom deleter that was passed to the constructor).
 *
 * A `shared_ptr` also stores another pointer, which is usually
 * (but not always) the same pointer as it owns. The stored pointer
 * can be retrieved by calling the `get()` member function.
 *
 * The equality and relational operators for `shared_ptr` only compare
 * the stored pointer returned by `get()`, not the owned pointer.
 * To test whether two `shared_ptr` objects share ownership of the same
 * pointer see `std::shared_ptr::owner_before` and `std::owner_less`.
*/
template<typename _Tp>
  class shared_ptr : public __shared_ptr<_Tp>
  {
    template<typename... _Args>
using _Constructible = typename enable_if<
 is_constructible<__shared_ptr<_Tp>, _Args...>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
>::type;

  public:

    /// The type pointed to by the stored pointer, remove_extent_t<_Tp>
    using element_type = typename __shared_ptr<_Tp>::element_type;

138#if __cplusplus201703L >= 201703L
139# define __cpp_lib_shared_ptr_weak_type201606 201606
    /// The corresponding weak_ptr type for this shared_ptr
    using weak_type = weak_ptr<_Tp>;
142#endif
    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count()==0 && get()==0
     */
    constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

    shared_ptr(const shared_ptr&) noexcept = default; ///< Copy constructor

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
     *  @param  __p  A pointer that is convertible to element_type*.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
     */
    template<typename _Yp, typename = _Constructible<_Yp*>>
explicit
shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter,
      typename = _Constructible<_Yp*, _Deleter>>
shared_ptr(_Yp* __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _Constructible<_Yp*, _Deleter, _Alloc>>
shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    // Aliasing constructor

    /**
     *  @brief  Constructs a `shared_ptr` instance that stores `__p`
     *          and shares ownership with `__r`.
     *  @param  __r  A `shared_ptr`.
     *  @param  __p  A pointer that will remain valid while `*__r` is valid.
     *  @post   `get() == __p && use_count() == __r.use_count()`
     *
     *  This can be used to construct a `shared_ptr` to a sub-object
     *  of an object managed by an existing `shared_ptr`. The complete
     *  object will remain valid while any `shared_ptr` owns it, even
     *  if they don't store a pointer to the complete object.
     *
     * @code
     * shared_ptr<pair<int,int>> pii(new pair<int,int>());
     * shared_ptr<int> pi(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }

259#if __cplusplus201703L > 201703L
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2996. Missing rvalue overloads for shared_ptr operations
    /**
     *  @brief  Constructs a `shared_ptr` instance that stores `__p`
     *          and shares ownership with `__r`.
     *  @param  __r  A `shared_ptr`.
     *  @param  __p  A pointer that will remain valid while `*__r` is valid.
     *  @post   `get() == __p && !__r.use_count() && !__r.get()`
     *
     *  This can be used to construct a `shared_ptr` to a sub-object
     *  of an object managed by an existing `shared_ptr`. The complete
     *  object will remain valid while any `shared_ptr` owns it, even
     *  if they don't store a pointer to the complete object.
     *
     * @code
     * shared_ptr<pair<int,int>> pii(new pair<int,int>());
     * shared_ptr<int> pi1(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * shared_ptr<int> pi2(std::move(pii), &pii->second);
     * assert(pii.use_count() == 0);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(std::move(__r), __p) { }
285#endif
    /**
     *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
     *          otherwise construct a %shared_ptr that shares ownership
     *          with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @post   get() == __r.get() && use_count() == __r.use_count()
     */
    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
shared_ptr(const shared_ptr<_Yp>& __r) noexcept
      : __shared_ptr<_Tp>(__r) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    shared_ptr(shared_ptr&& __r) noexcept
    : __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
shared_ptr(shared_ptr<_Yp>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
     *          and stores a copy of the pointer stored in @a __r.
     *  @param  __r  A weak_ptr.
     *  @post   use_count() == __r.use_count()
     *  @throw  bad_weak_ptr when __r.expired(),
     *          in which case the constructor has no effect.
     */
    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __shared_ptr<_Tp>(__r) { }

327#if _GLIBCXX_USE_DEPRECATED1
328#pragma GCC diagnostic push
329#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
332#pragma GCC diagnostic pop
333#endif

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2399. shared_ptr's constructor from unique_ptr should be constrained
    template<typename _Yp, typename _Del,
      typename = _Constructible<unique_ptr<_Yp, _Del>>>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }

342#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
    // This non-standard constructor exists to support conversions that
    // were possible in C++11 and C++14 but are ill-formed in C++17.
    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
_Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
350#endif

    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count() == 0 && get() == nullptr
     */
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

    shared_ptr& operator=(const shared_ptr&) noexcept = default;

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(__r);
 return *this;
}

368#if _GLIBCXX_USE_DEPRECATED1
369#pragma GCC diagnostic push
370#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
378#pragma GCC diagnostic pop
379#endif

    shared_ptr&
    operator=(shared_ptr&& __r) noexcept
    {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
    }

    template<class _Yp>
_Assignable<shared_ptr<_Yp>>
operator=(shared_ptr<_Yp>&& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    template<typename _Yp, typename _Del>
_Assignable<unique_ptr<_Yp, _Del>>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

  private:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
8
←
Calling constructor for '__shared_ptr<SwFrameControl, __gnu_cxx::_S_atomic>'→
27
←
Returning from constructor for '__shared_ptr<SwFrameControl, __gnu_cxx::_S_atomic>'→
{ }

    template<typename _Yp, typename _Alloc, typename... _Args>
friend shared_ptr<_Yp>
allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is non-standard, it is used by weak_ptr::lock().
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
    : __shared_ptr<_Tp>(__r, std::nothrow) { }

    friend class weak_ptr<_Tp>;
  };

422#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  shared_ptr(weak_ptr<_Tp>) ->  shared_ptr<_Tp>;
template<typename _Tp, typename _Del>
  shared_ptr(unique_ptr<_Tp, _Del>) ->  shared_ptr<_Tp>;
427#endif

// 20.7.2.2.7 shared_ptr comparisons

/// @relates shared_ptr @{

/// Equality operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

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

445#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Up>
  inline strong_ordering
  operator<=>(const shared_ptr<_Tp>& __a,
const shared_ptr<_Up>& __b) noexcept
  { return compare_three_way()(__a.get(), __b.get()); }

template<typename _Tp>
  inline strong_ordering
  operator<=>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using pointer = typename shared_ptr<_Tp>::element_type*;
    return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
  }
459#else
/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !__a; }

/// Inequality operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

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

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

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    using _Up_elt = typename shared_ptr<_Up>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

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

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

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return __a < nullptr; }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

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

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(nullptr < __a); }
566#endif

// 20.7.2.2.8 shared_ptr specialized algorithms.

/// Swap overload for shared_ptr
template<typename _Tp>
  inline void
  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts.

/// Convert type of `shared_ptr`, via `static_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr`, via `const_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr`, via `dynamic_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

607#if __cplusplus201703L >= 201703L
/// Convert type of `shared_ptr`, via `reinterpret_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }

617#if __cplusplus201703L > 201703L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2996. Missing rvalue overloads for shared_ptr operations

/// Convert type of `shared_ptr` rvalue, via `static_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 static_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr` rvalue, via `const_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 const_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr` rvalue, via `dynamic_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(std::move(__r), __p);
    return _Sp();
  }

/// Convert type of `shared_ptr` rvalue, via `reinterpret_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
661#endif // C++20
662#endif // C++17

// @}

/**
 * @brief  A non-owning observer for a pointer owned by a shared_ptr
 *
 * A weak_ptr provides a safe alternative to a raw pointer when you want
 * a non-owning reference to an object that is managed by a shared_ptr.
 *
 * Unlike a raw pointer, a weak_ptr can be converted to a new shared_ptr
 * that shares ownership with every other shared_ptr that already owns
 * the pointer. In other words you can upgrade from a non-owning "weak"
 * reference to an owning shared_ptr, without having access to any of
 * the existing shared_ptr objects.
 *
 * Also unlike a raw pointer, a weak_ptr does not become "dangling" after
 * the object it points to has been destroyed. Instead, a weak_ptr
 * becomes _expired_ and can no longer be converted to a shared_ptr that
 * owns the freed pointer, so you cannot accidentally access the pointed-to
 * object after it has been destroyed.
 */
template<typename _Tp>
  class weak_ptr : public __weak_ptr<_Tp>
  {
    template<typename _Arg>
using _Constructible = typename enable_if<
 is_constructible<__weak_ptr<_Tp>, _Arg>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
>::type;

  public:
    constexpr weak_ptr() noexcept = default;

    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(const weak_ptr&) noexcept = default;

    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
weak_ptr(const weak_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(weak_ptr&&) noexcept = default;

    template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }

    weak_ptr&
    operator=(const weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<const weak_ptr<_Yp>&>
operator=(const weak_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    weak_ptr&
    operator=(weak_ptr&& __r) noexcept = default;

    template<typename _Yp>
_Assignable<weak_ptr<_Yp>>
operator=(weak_ptr<_Yp>&& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    shared_ptr<_Tp>
    lock() const noexcept
    { return shared_ptr<_Tp>(*this, std::nothrow); }
  };

752#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
755#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
/// Swap overload for weak_ptr
/// @relates weak_ptr
template<typename _Tp>
  inline void
  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }


/// Primary template owner_less
template<typename _Tp = void>
  struct owner_less;

/// Void specialization of owner_less compares either shared_ptr or weak_ptr
template<>
  struct owner_less<void> : _Sp_owner_less<void, void>
  { };

/// Partial specialization of owner_less for shared_ptr.
template<typename _Tp>
  struct owner_less<shared_ptr<_Tp>>
  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
  { };

/// Partial specialization of owner_less for weak_ptr.
template<typename _Tp>
  struct owner_less<weak_ptr<_Tp>>
  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
  { };

/**
 *  @brief Base class allowing use of member function shared_from_this.
 */
template<typename _Tp>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept { }

    enable_shared_from_this(const enable_shared_from_this&) noexcept { }

    enable_shared_from_this&
    operator=(const enable_shared_from_this&) noexcept
    { return *this; }

    ~enable_shared_from_this() { }

  public:
    shared_ptr<_Tp>
    shared_from_this()
    { return shared_ptr<_Tp>(this->_M_weak_this); }

    shared_ptr<const _Tp>
    shared_from_this() const
    { return shared_ptr<const _Tp>(this->_M_weak_this); }

813#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
814#define __cpp_lib_enable_shared_from_this201603 201603
    weak_ptr<_Tp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    weak_ptr<const _Tp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
822#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    // Found by ADL when this is an associated class.
    friend const enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<>&,
		     const enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable weak_ptr<_Tp>  _M_weak_this;
  };

/// @relates shared_ptr @{

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __a     An allocator.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  An exception thrown from @a _Alloc::allocate or from the
 *          constructor of @a _Tp.
 *
 *  A copy of @a __a will be used to allocate memory for the shared_ptr
 *  and the new object.
 */
template<typename _Tp, typename _Alloc, typename... _Args>
  inline shared_ptr<_Tp>
  allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
7
←
Calling constructor for 'shared_ptr<SwFrameControl>'→
28
←
Returning from constructor for 'shared_ptr<SwFrameControl>'→
	     std::forward<_Args>(__args)...);
  }

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  std::bad_alloc, or an exception thrown from the
 *          constructor of @a _Tp.
 */
template<typename _Tp, typename... _Args>
  inline shared_ptr<_Tp>
  make_shared(_Args&&... __args)
  {
    typedef typename std::remove_cv<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
6
←
Calling 'allocate_shared<SwFrameControl, std::allocator<SwFrameControl>, SwPageBreakWin *>'→
29
←
Returning; memory was released via 2nd parameter→
		       std::forward<_Args>(__args)...);
  }

/// std::hash specialization for shared_ptr.
template<typename _Tp>
  struct hash<shared_ptr<_Tp>>
  : public __hash_base<size_t, shared_ptr<_Tp>>
  {
    size_t
    operator()(const shared_ptr<_Tp>& __s) const noexcept
    {
return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
    }
  };

// @} relates shared_ptr
// @} group pointer_abstractions

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

  // Provide the strong exception-safety guarantee when emplacing a
  // shared_ptr into a variant.
  template<typename _Tp>
    struct _Never_valueless_alt<std::shared_ptr<_Tp>>
    : std::true_type
    { };

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

915_GLIBCXX_END_NAMESPACE_VERSION
916} // namespace

918#endif // _SHARED_PTR_H

←

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

→

1// shared_ptr and weak_ptr implementation details -*- C++ -*-

3// Copyright (C) 2007-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// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

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

49#ifndef _SHARED_PTR_BASE_H1
50#define _SHARED_PTR_BASE_H1 1

52#include <typeinfo>
53#include <bits/allocated_ptr.h>
54#include <bits/refwrap.h>
55#include <bits/stl_function.h>
56#include <ext/aligned_buffer.h>
57#if __cplusplus201703L > 201703L
58# include <compare>
59#endif

61namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
62{
63_GLIBCXX_BEGIN_NAMESPACE_VERSION

65#if _GLIBCXX_USE_DEPRECATED1
66#pragma GCC diagnostic push
67#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
69#pragma GCC diagnostic pop
70#endif

/**
 *  @brief  Exception possibly thrown by @c shared_ptr.
 *  @ingroup exceptions
 */
class bad_weak_ptr : public std::exception
{
public:
  virtual char const* what() const noexcept;

  virtual ~bad_weak_ptr() noexcept;
};

// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
inline void
__throw_bad_weak_ptr()
{ _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(throw (bad_weak_ptr())); }

using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;

// Empty helper class except when the template argument is _S_mutex.
template<_Lock_policy _Lp>
  class _Mutex_base
  {
  protected:
    // The atomic policy uses fully-fenced builtins, single doesn't care.
    enum { _S_need_barriers = 0 };
  };

template<>
  class _Mutex_base<_S_mutex>
  : public __gnu_cxx::__mutex
  {
  protected:
    // This policy is used when atomic builtins are not available.
    // The replacement atomic operations might not have the necessary
    // memory barriers.
    enum { _S_need_barriers = 1 };
  };

template<_Lock_policy _Lp = __default_lock_policy>
  class _Sp_counted_base
  : public _Mutex_base<_Lp>
  {
  public:
    _Sp_counted_base() noexcept
    : _M_use_count(1), _M_weak_count(1) { }

    virtual
    ~_Sp_counted_base() noexcept
    { }

    // Called when _M_use_count drops to zero, to release the resources
    // managed by *this.
    virtual void
    _M_dispose() noexcept = 0;

    // Called when _M_weak_count drops to zero.
    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept = 0;

    void
    _M_add_ref_copy()
    { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

    void
    _M_add_ref_lock();

    bool
    _M_add_ref_lock_nothrow();

    void
    _M_release() noexcept
    {
      // Be race-detector-friendly.  For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
   _M_dispose();
   // There must be a memory barrier between dispose() and destroy()
   // to ensure that the effects of dispose() are observed in the
   // thread that runs destroy().
   // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }

          // Be race-detector-friendly.  For more info see bits/c++config.
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
            }
 }
    }

    void
    _M_weak_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

    void
    _M_weak_release() noexcept
    {
      // Be race-detector-friendly. For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
       // See _M_release(),
       // destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }
   _M_destroy();
 }
    }

    long
    _M_get_use_count() const noexcept
    {
      // No memory barrier is used here so there is no synchronization
      // with other threads.
      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0);
    }

  private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  };

template<>
  inline void
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock()
  {
    if (_M_use_count == 0)
__throw_bad_weak_ptr();
    ++_M_use_count;
  }

template<>
  inline void
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 __throw_bad_weak_ptr();
}
  }

template<>
  inline void
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   __throw_bad_weak_ptr();
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
  }

template<>
  inline bool
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock_nothrow()
  {
    if (_M_use_count == 0)
return false;
    ++_M_use_count;
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock_nothrow()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 return false;
}
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock_nothrow()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   return false;
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
    return true;
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_add_ref_copy()
  { ++_M_use_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_release() noexcept
  {
    if (--_M_use_count == 0)
      {
        _M_dispose();
        if (--_M_weak_count == 0)
          _M_destroy();
      }
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
  { ++_M_weak_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_release() noexcept
  {
    if (--_M_weak_count == 0)
      _M_destroy();
  }

template<>
  inline long
  _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
  { return _M_use_count; }


// Forward declarations.
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __shared_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __weak_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __enable_shared_from_this;

template<typename _Tp>
  class shared_ptr;

template<typename _Tp>
  class weak_ptr;

template<typename _Tp>
  struct owner_less;

template<typename _Tp>
  class enable_shared_from_this;

template<_Lock_policy _Lp = __default_lock_policy>
  class __weak_count;

template<_Lock_policy _Lp = __default_lock_policy>
  class __shared_count;


// Counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
  class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  {
  public:
    explicit
    _Sp_counted_ptr(_Ptr __p) noexcept
    : _M_ptr(__p) { }

    virtual void
    _M_dispose() noexcept
    { delete _M_ptr; }

    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept
    { return nullptr; }

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

  private:
    _Ptr             _M_ptr;
  };

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

template<int _Nm, typename _Tp,
  bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
  struct _Sp_ebo_helper;

/// Specialization using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
  };

/// Specialization not using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, false>
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh)
    { return __eboh._M_tp; }

  private:
    _Tp _M_tp;
  };

// Support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;

    public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
{ }

_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

_Ptr _M_ptr;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
    : _M_impl(__p, std::move(__d), _Alloc()) { }

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
    : _M_impl(__p, std::move(__d), __a) { }

    ~_Sp_counted_deleter() noexcept { }

    virtual void
    _M_dispose() noexcept
    { _M_impl._M_del()(_M_impl._M_ptr); }

    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
    }

    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
487#if __cpp_rtti199711L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
493#else
      return nullptr;
495#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag
{
private:
  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    friend class _Sp_counted_ptr_inplace;

  static const type_info&
  _S_ti() noexcept _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
  {
    alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
    return reinterpret_cast<const type_info&>(__tag);
  }

  static bool _S_eq(const type_info&) noexcept;
};

template<typename _Alloc>
  struct _Sp_alloc_shared_tag
  {
    const _Alloc& _M_a;
  };

template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Alloc>	_A_base;

    public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

    // Alloc parameter is not a reference so doesn't alias anything in __args
    template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070.  allocate_shared should use allocator_traits<A>::construct
 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
11
←
Calling 'allocator_traits::construct'→
24
←
Returning; memory was released via 3rd parameter→
     std::forward<_Args>(__args)...); // might throw
}

    ~_Sp_counted_ptr_inplace() noexcept { }

    virtual void
    _M_dispose() noexcept
    {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
    }

    // Override because the allocator needs to know the dynamic type
    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
    }

  private:
    friend class __shared_count<_Lp>; // To be able to call _M_ptr().

    // No longer used, but code compiled against old libstdc++ headers
    // might still call it from __shared_ptr ctor to get the pointer out.
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept override
    {
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
   ||
587#if __cpp_rtti199711L
   __ti == typeid(_Sp_make_shared_tag)
589#else
   _Sp_make_shared_tag::_S_eq(__ti)
591#endif
  )
 return __ptr;
return nullptr;
    }

    _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

    _Impl _M_impl;
  };

// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
{
  template<typename _Yp>
    void operator()(_Yp* __p) const { delete[] __p; }
};

template<_Lock_policy _Lp>
  class __shared_count
  {
    template<typename _Tp>
struct __not_alloc_shared_tag { using type = void; };

    template<typename _Tp>
struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };

  public:
    constexpr __shared_count() noexcept : _M_pi(0)
    { }

    template<typename _Ptr>
      explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
 __trytry
   {
     _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
   }
 __catch(...)catch(...)
   {
     delete __p;
     __throw_exception_againthrow;
   }
}

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
{ }

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 __trytry
   {
     typename _Sp_cd_type::__allocator_type __a2(__a);
     auto __guard = std::__allocate_guarded(__a2);
     _Sp_cd_type* __mem = __guard.get();
     ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
     _M_pi = __mem;
     __guard = nullptr;
   }
 __catch(...)catch(...)
   {
     __d(__p); // Call _Deleter on __p.
     __throw_exception_againthrow;
   }
}

    template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
       _Args&&... __args)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
 auto __guard = std::__allocate_guarded(__a2);
 _Sp_cp_type* __mem = __guard.get();
 auto __pi = ::new (__mem)
   _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
10
←
Calling constructor for '_Sp_counted_ptr_inplace<SwFrameControl, std::allocator<SwFrameControl>, __gnu_cxx::_S_atomic>'→
25
←
Returning from constructor for '_Sp_counted_ptr_inplace<SwFrameControl, std::allocator<SwFrameControl>, __gnu_cxx::_S_atomic>'→
 __guard = nullptr;
 _M_pi = __pi;
 __p = __pi->_M_ptr();
}

689#if _GLIBCXX_USE_DEPRECATED1
690#pragma GCC diagnostic push
691#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
696#pragma GCC diagnostic pop
697#endif

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
      explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2415. Inconsistency between unique_ptr and shared_ptr
 if (__r.get() == nullptr)
   return;

 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
 using _Del2 = typename conditional<is_reference<_Del>::value,
     reference_wrapper<typename remove_reference<_Del>::type>,
     _Del>::type;
 using _Sp_cd_type
   = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
 using _Alloc = allocator<_Sp_cd_type>;
 using _Alloc_traits = allocator_traits<_Alloc>;
 _Alloc __a;
 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
 _Alloc_traits::construct(__a, __mem, __r.release(),
		   __r.get_deleter());  // non-throwing
 _M_pi = __mem;
}

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

    ~__shared_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_release();
    }

    __shared_count(const __shared_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != 0)
 _M_pi->_M_add_ref_copy();
    }

    __shared_count&
    operator=(const __shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
 {
   if (__tmp != 0)
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
     _M_pi->_M_release();
   _M_pi = __tmp;
 }
return *this;
    }

    void
    _M_swap(__shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool
    _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __weak_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };


template<_Lock_policy _Lp>
  class __weak_count
  {
  public:
    constexpr __weak_count() noexcept : _M_pi(nullptr)
    { }

    __weak_count(const __shared_count<_Lp>& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(const __weak_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(__weak_count&& __r) noexcept
    : _M_pi(__r._M_pi)
    { __r._M_pi = nullptr; }

    ~__weak_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
    }

    __weak_count&
    operator=(const __shared_count<_Lp>& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(const __weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(__weak_count&& __r) noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __r._M_pi;
      __r._M_pi = nullptr;
return *this;
    }

    void
    _M_swap(__weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_less(const __weak_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __shared_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
    else
__throw_bad_weak_ptr();
  }

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::
  __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
  }

918#define __cpp_lib_shared_ptr_arrays201611L 201611L

// Helper traits for shared_ptr of array:

// A pointer type Y* is said to be compatible with a pointer type T* when
// either Y* is convertible to T* or Y is U[N] and T is U cv [].
template<typename _Yp_ptr, typename _Tp_ptr>
  struct __sp_compatible_with
  : false_type
  { };

template<typename _Yp, typename _Tp>
  struct __sp_compatible_with<_Yp*, _Tp*>
  : is_convertible<_Yp*, _Tp*>::type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
  : true_type
  { };

// Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
template<typename _Up, size_t _Nm, typename _Yp, typename = void>
  struct __sp_is_constructible_arrN
  : false_type
  { };

template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
  : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
  { };

// Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
template<typename _Up, typename _Yp, typename = void>
  struct __sp_is_constructible_arr
  : false_type
  { };

template<typename _Up, typename _Yp>
  struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
  : is_convertible<_Yp(*)[], _Up(*)[]>::type
  { };

// Trait to check if shared_ptr<T> can be constructed from Y*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible;

// When T is U[N], Y(*)[N] shall be convertible to T*;
template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible<_Up[_Nm], _Yp>
  : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
  { };

// when T is U[], Y(*)[] shall be convertible to T*;
template<typename _Up, typename _Yp>
  struct __sp_is_constructible<_Up[], _Yp>
  : __sp_is_constructible_arr<_Up, _Yp>::type
  { };

// otherwise, Y* shall be convertible to T*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible
  : is_convertible<_Yp*, _Tp*>::type
  { };


// Define operator* and operator-> for shared_ptr<T>.
template<typename _Tp, _Lock_policy _Lp,
  bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
  class __shared_ptr_access
  {
  public:
    using element_type = _Tp;

    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

// Define operator-> for shared_ptr<cv void>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, false, true>
  {
  public:
    using element_type = _Tp;

    element_type*
    operator->() const noexcept
    {
auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
_GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
return __ptr;
    }
  };

// Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, true, false>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

1050#if __cplusplus201703L <= 201402L
    [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }
1066#endif

    element_type&
    operator[](ptrdiff_t __i) const
    {
__glibcxx_assert(_M_get() != nullptr);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value);
return _M_get()[__i];
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr
  : public __shared_ptr_access<_Tp, _Lp>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

  private:
    // Constraint for taking ownership of a pointer of type _Yp*:
    template<typename _Yp>
using _SafeConv
 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

    // Constraint for construction from shared_ptr and weak_ptr:
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __shared_ptr&>;

    // Constraint for construction from unique_ptr:
    template<typename _Yp, typename _Del, typename _Res = void,
      typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
using _UniqCompatible = typename enable_if<__and_<
 __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
 >::value, _Res>::type;

    // Constraint for assignment from unique_ptr:
    template<typename _Yp, typename _Del>
using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

  public:

1117#if __cplusplus201703L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1119#endif

    constexpr __shared_ptr() noexcept
    : _M_ptr(0), _M_refcount()
    { }

    template<typename _Yp, typename = _SafeConv<_Yp>>
explicit
__shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
{
 static_assert( !is_void<_Yp>::value, "incomplete type" );
 static_assert( sizeof(_Yp) > 0, "incomplete type" );
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, std::move(__d))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, std::move(__d))
{ }

    template<typename _Deleter, typename _Alloc>
      __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
{ }

    // Aliasing constructor
    template<typename _Yp>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }

    // Aliasing constructor
    template<typename _Yp>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
    ~__shared_ptr() = default;

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __shared_ptr(__shared_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount()
    {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
    }

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    template<typename _Yp, typename = _Compatible<_Yp>>
explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
: _M_refcount(__r._M_refcount) // may throw
{
 // It is now safe to copy __r._M_ptr, as
 // _M_refcount(__r._M_refcount) did not throw.
 _M_ptr = __r._M_ptr;
}

    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
      typename = _UniqCompatible<_Yp, _Del>>
__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1225#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
  protected:
    // If an exception is thrown this constructor has no effect.
    template<typename _Tp1, typename _Del,
      typename enable_if<__and_<
 __not_<is_array<_Tp>>, is_array<_Tp1>,
        is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
      >::value, bool>::type = true>
__shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1241#endif

1243#if _GLIBCXX_USE_DEPRECATED1
1244#pragma GCC diagnostic push
1245#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1249#pragma GCC diagnostic pop
1250#endif

    constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 return *this;
}

1263#if _GLIBCXX_USE_DEPRECATED1
1264#pragma GCC diagnostic push
1265#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1273#pragma GCC diagnostic pop
1274#endif

    __shared_ptr&
    operator=(__shared_ptr&& __r) noexcept
    {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
    }

    template<class _Yp>
_Assignable<_Yp>
operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    template<typename _Yp, typename _Del>
_UniqAssignable<_Yp, _Del>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    void
    reset() noexcept
    { __shared_ptr().swap(*this); }

    template<typename _Yp>
_SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
 // Catch self-reset errors.
 __glibcxx_assert(__p == 0 || __p != _M_ptr);
 __shared_ptr(__p).swap(*this);
}

    template<typename _Yp, typename _Deleter>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d)
{ __shared_ptr(__p, std::move(__d)).swap(*this); }

    template<typename _Yp, typename _Deleter, typename _Alloc>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d, _Alloc __a)
      { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }

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

    /// Return true if the stored pointer is not null.
    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    /// Return true if use_count() == 1.
    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

    /// If *this owns a pointer, return the number of owners, otherwise zero.
    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    /// Exchange both the owned pointer and the stored pointer.
    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    /** @brief Define an ordering based on ownership.
     *
     * This function defines a strict weak ordering between two shared_ptr
     * or weak_ptr objects, such that one object is less than the other
     * unless they share ownership of the same pointer, or are both empty.
     * @{
    */
    template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }
    // @}

  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
9
←
Calling constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
26
←
Returning from constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
{ _M_enable_shared_from_this_with(_M_ptr); }

    template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
      typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is used by __weak_ptr::lock() and
    // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
    : _M_refcount(__r._M_refcount, std::nothrow)
    {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }

    friend class __weak_ptr<_Tp, _Lp>;

  private:

    template<typename _Yp>
using __esft_base_t = decltype(__enable_shared_from_this_base(
     std::declval<const __shared_count<_Lp>&>(),
     std::declval<_Yp*>()));

    // Detect an accessible and unambiguous enable_shared_from_this base.
    template<typename _Yp, typename = void>
struct __has_esft_base
: false_type { };

    template<typename _Yp>
struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
: __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
   __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_refcount._M_get_deleter(__ti); }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

    template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

    template<typename _Del, typename _Tp1>
friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;

    element_type*	   _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.
  };


// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !__a; }

1448#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline strong_ordering
  operator<=>(const __shared_ptr<_Tp, _Lp>& __a,
const __shared_ptr<_Up, _Lp>& __b) noexcept
  { return compare_three_way()(__a.get(), __b.get()); }

template<typename _Tp, _Lock_policy _Lp>
  inline strong_ordering
  operator<=>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using pointer = typename __shared_ptr<_Tp, _Lp>::element_type*;
    return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
  }
1462#else
template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !__a; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a,
     const __shared_ptr<_Up, _Lp>& __b) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp1, _Lp>& __a,
     const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(nullptr < __a); }
1558#endif // three-way comparison

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// static_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// const_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// dynamic_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

1609#if __cplusplus201703L > 201402L
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
1617#endif

template<typename _Tp, _Lock_policy _Lp>
  class __weak_ptr
  {
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __weak_ptr&>;

  public:
    using element_type = typename remove_extent<_Tp>::type;

    constexpr __weak_ptr() noexcept
    : _M_ptr(nullptr), _M_refcount()
    { }

    __weak_ptr(const __weak_ptr&) noexcept = default;

    ~__weak_ptr() = default;

    // The "obvious" converting constructor implementation:
    //
    //  template<typename _Tp1>
    //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
    //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
    //    { }
    //
    // has a serious problem.
    //
    //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
    //  conversion may require access to *__r._M_ptr (virtual inheritance).
    //
    // It is not possible to avoid spurious access violations since
    // in multithreaded programs __r._M_ptr may be invalidated at any point.
    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
      { _M_ptr = __r.lock().get(); }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __weak_ptr(__weak_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
    { __r._M_ptr = nullptr; }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

    __weak_ptr&
    operator=(const __weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = __r._M_refcount;
 return *this;
}

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount;
 return *this;
}

    __weak_ptr&
    operator=(__weak_ptr&& __r) noexcept
    {
_M_ptr = __r._M_ptr;
_M_refcount = std::move(__r._M_refcount);
__r._M_ptr = nullptr;
return *this;
    }

    template<typename _Yp>
_Assignable<_Yp>
operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
}

    __shared_ptr<_Tp, _Lp>
    lock() const noexcept
    { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    bool
    expired() const noexcept
    { return _M_refcount._M_get_use_count() == 0; }

    template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    void
    reset() noexcept
    { __weak_ptr().swap(*this); }

    void
    swap(__weak_ptr& __s) noexcept
    {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
    }

  private:
    // Used by __enable_shared_from_this.
    void
    _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    {
if (use_count() == 0)
 {
   _M_ptr = __ptr;
   _M_refcount = __refcount;
 }
    }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    friend class __enable_shared_from_this<_Tp, _Lp>;
    friend class enable_shared_from_this<_Tp>;

    element_type*	 _M_ptr;         // Contained pointer.
    __weak_count<_Lp>  _M_refcount;    // Reference counter.
  };

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

template<typename _Tp, typename _Tp1>
  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  {
    bool
    operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }
  };

template<>
  struct _Sp_owner_less<void, void>
  {
    template<typename _Tp, typename _Up>
auto
operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
-> decltype(__lhs.owner_before(__rhs))
{ return __lhs.owner_before(__rhs); }

    using is_transparent = void;
  };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  { };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__weak_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  { };


template<typename _Tp, _Lock_policy _Lp>
  class __enable_shared_from_this
  {
  protected:
    constexpr __enable_shared_from_this() noexcept { }

    __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

    __enable_shared_from_this&
    operator=(const __enable_shared_from_this&) noexcept
    { return *this; }

    ~__enable_shared_from_this() { }

  public:
    __shared_ptr<_Tp, _Lp>
    shared_from_this()
    { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

    __shared_ptr<const _Tp, _Lp>
    shared_from_this() const
    { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

1836#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
    __weak_ptr<_Tp, _Lp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    __weak_ptr<const _Tp, _Lp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
1844#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    friend const __enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<_Lp>&,
		     const __enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  };

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
  typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
  typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
			      std::forward<_Args>(__args)...);
  }

/// std::hash specialization for __shared_ptr.
template<typename _Tp, _Lock_policy _Lp>
  struct hash<__shared_ptr<_Tp, _Lp>>
  : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  {
    size_t
    operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
    {
return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
   __s.get());
    }
  };

1895_GLIBCXX_END_NAMESPACE_VERSION
1896} // namespace

1898#endif // _SHARED_PTR_BASE_H

←

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

→

1// Allocator traits -*- C++ -*-

3// Copyright (C) 2011-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/alloc_traits.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _ALLOC_TRAITS_H1
31#define _ALLOC_TRAITS_H1 1

33#include <bits/stl_construct.h>
34#include <bits/memoryfwd.h>
35#if __cplusplus201703L >= 201103L
36# include <bits/allocator.h>
37# include <bits/ptr_traits.h>
38# include <ext/numeric_traits.h>
39#endif

41namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION

45#if __cplusplus201703L >= 201103L
46#define __cpp_lib_allocator_traits_is_always_equal201411 201411

struct __allocator_traits_base
{
  template<typename _Tp, typename _Up, typename = void>
    struct __rebind : __replace_first_arg<_Tp, _Up> { };

  template<typename _Tp, typename _Up>
    struct __rebind<_Tp, _Up,
      __void_t<typename _Tp::template rebind<_Up>::other>>
    { using type = typename _Tp::template rebind<_Up>::other; };

protected:
  template<typename _Tp>
    using __pointer = typename _Tp::pointer;
  template<typename _Tp>
    using __c_pointer = typename _Tp::const_pointer;
  template<typename _Tp>
    using __v_pointer = typename _Tp::void_pointer;
  template<typename _Tp>
    using __cv_pointer = typename _Tp::const_void_pointer;
  template<typename _Tp>
    using __pocca = typename _Tp::propagate_on_container_copy_assignment;
  template<typename _Tp>
    using __pocma = typename _Tp::propagate_on_container_move_assignment;
  template<typename _Tp>
    using __pocs = typename _Tp::propagate_on_container_swap;
  template<typename _Tp>
    using __equal = typename _Tp::is_always_equal;
};

template<typename _Alloc, typename _Up>
  using __alloc_rebind
    = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;

/**
 * @brief  Uniform interface to all allocator types.
 * @ingroup allocators
*/
template<typename _Alloc>
  struct allocator_traits : __allocator_traits_base
  {
    /// The allocator type
    typedef _Alloc allocator_type;
    /// The allocated type
    typedef typename _Alloc::value_type value_type;

    /**
     * @brief   The allocator's pointer type.
     *
     * @c Alloc::pointer if that type exists, otherwise @c value_type*
    */
    using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

  private:
    // Select _Func<_Alloc> or pointer_traits<pointer>::rebind<_Tp>
    template<template<typename> class _Func, typename _Tp, typename = void>
struct _Ptr
{
 using type = typename pointer_traits<pointer>::template rebind<_Tp>;
};

    template<template<typename> class _Func, typename _Tp>
struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
{
 using type = _Func<_Alloc>;
};

    // Select _A2::difference_type or pointer_traits<_Ptr>::difference_type
    template<typename _A2, typename _PtrT, typename = void>
struct _Diff
{ using type = typename pointer_traits<_PtrT>::difference_type; };

    template<typename _A2, typename _PtrT>
struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
{ using type = typename _A2::difference_type; };

    // Select _A2::size_type or make_unsigned<_DiffT>::type
    template<typename _A2, typename _DiffT, typename = void>
struct _Size : make_unsigned<_DiffT> { };

    template<typename _A2, typename _DiffT>
struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
{ using type = typename _A2::size_type; };

  public:
    /**
     * @brief   The allocator's const pointer type.
     *
     * @c Alloc::const_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<const value_type> </tt>
    */
    using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;

    /**
     * @brief   The allocator's void pointer type.
     *
     * @c Alloc::void_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<void> </tt>
    */
    using void_pointer = typename _Ptr<__v_pointer, void>::type;

    /**
     * @brief   The allocator's const void pointer type.
     *
     * @c Alloc::const_void_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<const void> </tt>
    */
    using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;

    /**
     * @brief   The allocator's difference type
     *
     * @c Alloc::difference_type if that type exists, otherwise
     * <tt> pointer_traits<pointer>::difference_type </tt>
    */
    using difference_type = typename _Diff<_Alloc, pointer>::type;

    /**
     * @brief   The allocator's size type
     *
     * @c Alloc::size_type if that type exists, otherwise
     * <tt> make_unsigned<difference_type>::type </tt>
    */
    using size_type = typename _Size<_Alloc, difference_type>::type;

    /**
     * @brief   How the allocator is propagated on copy assignment
     *
     * @c Alloc::propagate_on_container_copy_assignment if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_copy_assignment
= __detected_or_t<false_type, __pocca, _Alloc>;

    /**
     * @brief   How the allocator is propagated on move assignment
     *
     * @c Alloc::propagate_on_container_move_assignment if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_move_assignment
= __detected_or_t<false_type, __pocma, _Alloc>;

    /**
     * @brief   How the allocator is propagated on swap
     *
     * @c Alloc::propagate_on_container_swap if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_swap
= __detected_or_t<false_type, __pocs, _Alloc>;

    /**
     * @brief   Whether all instances of the allocator type compare equal.
     *
     * @c Alloc::is_always_equal if that type exists,
     * otherwise @c is_empty<Alloc>::type
    */
    using is_always_equal
= __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;

    template<typename _Tp>
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
    template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;

  private:
    template<typename _Alloc2>
static constexpr auto
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
-> decltype(__a.allocate(__n, __hint))
{ return __a.allocate(__n, __hint); }

    template<typename _Alloc2>
static constexpr pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
{ return __a.allocate(__n); }

    template<typename _Tp, typename... _Args>
struct __construct_helper
{
 template<typename _Alloc2,
   typename = decltype(std::declval<_Alloc2*>()->construct(
  std::declval<_Tp*>(), std::declval<_Args>()...))>
   static true_type __test(int);

 template<typename>
   static false_type __test(...);

 using type = decltype(__test<_Alloc>(0));
};

    template<typename _Tp, typename... _Args>
using __has_construct
 = typename __construct_helper<_Tp, _Args...>::type;

    template<typename _Tp, typename... _Args>
static _GLIBCXX14_CONSTEXPRconstexpr _Require<__has_construct<_Tp, _Args...>>
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
{ __a.construct(__p, std::forward<_Args>(__args)...); }

    template<typename _Tp, typename... _Args>
static _GLIBCXX14_CONSTEXPRconstexpr
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
	       is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
{
256#if __cplusplus201703L <= 201703L
 ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
258#else
 std::construct_at(__p, std::forward<_Args>(__args)...);
260#endif
}

    template<typename _Alloc2, typename _Tp>
static _GLIBCXX14_CONSTEXPRconstexpr auto
_S_destroy(_Alloc2& __a, _Tp* __p, int)
noexcept(noexcept(__a.destroy(__p)))
-> decltype(__a.destroy(__p))
{ __a.destroy(__p); }

    template<typename _Alloc2, typename _Tp>
static _GLIBCXX14_CONSTEXPRconstexpr void
_S_destroy(_Alloc2&, _Tp* __p, ...)
noexcept(std::is_nothrow_destructible<_Tp>::value)
{ std::_Destroy(__p); }

    template<typename _Alloc2>
static constexpr auto
_S_max_size(_Alloc2& __a, int)
-> decltype(__a.max_size())
{ return __a.max_size(); }

    template<typename _Alloc2>
static constexpr size_type
_S_max_size(_Alloc2&, ...)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2466. allocator_traits::max_size() default behavior is incorrect
 return __gnu_cxx::__numeric_traits<size_type>::__max
   / sizeof(value_type);
}

    template<typename _Alloc2>
static constexpr auto
_S_select(_Alloc2& __a, int)
-> decltype(__a.select_on_container_copy_construction())
{ return __a.select_on_container_copy_construction(); }

    template<typename _Alloc2>
static constexpr _Alloc2
_S_select(_Alloc2& __a, ...)
{ return __a; }

  public:

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *
     *  Calls @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(_Alloc& __a, size_type __n)
    { return __a.allocate(__n); }

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *  @param  __hint Aid to locality.
     *  @return Memory of suitable size and alignment for @a n objects
     *          of type @c value_type
     *
     *  Returns <tt> a.allocate(n, hint) </tt> if that expression is
     *  well-formed, otherwise returns @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
    { return _S_allocate(__a, __n, __hint, 0); }

    /**
     *  @brief  Deallocate memory.
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the memory to deallocate.
     *  @param  __n  The number of objects space was allocated for.
     *
     *  Calls <tt> a.deallocate(p, n) </tt>
    */
    static _GLIBCXX20_CONSTEXPR void
    deallocate(_Alloc& __a, pointer __p, size_type __n)
    { __a.deallocate(__p, __n); }

    /**
     *  @brief  Construct an object of type @a _Tp
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to memory of suitable size and alignment for Tp
     *  @param  __args Constructor arguments.
     *
     *  Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt>
     *  if that expression is well-formed, otherwise uses placement-new
     *  to construct an object of type @a _Tp at location @a __p from the
     *  arguments @a __args...
    */
    template<typename _Tp, typename... _Args>
static _GLIBCXX20_CONSTEXPR auto
construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(_S_construct(__a, __p,
		       std::forward<_Args>(__args)...)))
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); }

    /**
     *  @brief  Destroy an object of type @a _Tp
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the object to destroy
     *
     *  Calls @c __a.destroy(__p) if that expression is well-formed,
     *  otherwise calls @c __p->~_Tp()
    */
    template<typename _Tp>
static _GLIBCXX20_CONSTEXPR void
destroy(_Alloc& __a, _Tp* __p)
noexcept(noexcept(_S_destroy(__a, __p, 0)))
{ _S_destroy(__a, __p, 0); }

    /**
     *  @brief  The maximum supported allocation size
     *  @param  __a  An allocator.
     *  @return @c __a.max_size() or @c numeric_limits<size_type>::max()
     *
     *  Returns @c __a.max_size() if that expression is well-formed,
     *  otherwise returns @c numeric_limits<size_type>::max()
    */
    static _GLIBCXX20_CONSTEXPR size_type
    max_size(const _Alloc& __a) noexcept
    { return _S_max_size(__a, 0); }

    /**
     *  @brief  Obtain an allocator to use when copying a container.
     *  @param  __rhs  An allocator.
     *  @return @c __rhs.select_on_container_copy_construction() or @a __rhs
     *
     *  Returns @c __rhs.select_on_container_copy_construction() if that
     *  expression is well-formed, otherwise returns @a __rhs
    */
    static _GLIBCXX20_CONSTEXPR _Alloc
    select_on_container_copy_construction(const _Alloc& __rhs)
    { return _S_select(__rhs, 0); }
  };

401#if __cplusplus201703L > 201703L
402# define __cpp_lib_constexpr_dynamic_alloc 201907L
403#endif

/// Partial specialization for std::allocator.
template<typename _Tp>
  struct allocator_traits<allocator<_Tp>>
  {
    /// The allocator type
    using allocator_type = allocator<_Tp>;

    /// The allocated type
    using value_type = _Tp;

    /// The allocator's pointer type.
    using pointer = _Tp*;

    /// The allocator's const pointer type.
    using const_pointer = const _Tp*;

    /// The allocator's void pointer type.
    using void_pointer = void*;

    /// The allocator's const void pointer type.
    using const_void_pointer = const void*;

    /// The allocator's difference type
    using difference_type = std::ptrdiff_t;

    /// The allocator's size type
    using size_type = std::size_t;

    /// How the allocator is propagated on copy assignment
    using propagate_on_container_copy_assignment = false_type;

    /// How the allocator is propagated on move assignment
    using propagate_on_container_move_assignment = true_type;

    /// How the allocator is propagated on swap
    using propagate_on_container_swap = false_type;

    /// Whether all instances of the allocator type compare equal.
    using is_always_equal = true_type;

    template<typename _Up>
using rebind_alloc = allocator<_Up>;

    template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *
     *  Calls @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(allocator_type& __a, size_type __n)
    { return __a.allocate(__n); }

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *  @param  __hint Aid to locality.
     *  @return Memory of suitable size and alignment for @a n objects
     *          of type @c value_type
     *
     *  Returns <tt> a.allocate(n, hint) </tt>
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
    {
475#if __cplusplus201703L <= 201703L
return __a.allocate(__n, __hint);
477#else
return __a.allocate(__n);
479#endif
    }

    /**
     *  @brief  Deallocate memory.
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the memory to deallocate.
     *  @param  __n  The number of objects space was allocated for.
     *
     *  Calls <tt> a.deallocate(p, n) </tt>
    */
    static _GLIBCXX20_CONSTEXPR void
    deallocate(allocator_type& __a, pointer __p, size_type __n)
    { __a.deallocate(__p, __n); }

    /**
     *  @brief  Construct an object of type `_Up`
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to memory of suitable size and alignment for
     *	       an object of type `_Up`.
     *  @param  __args Constructor arguments.
     *
     *  Calls `__a.construct(__p, std::forward<_Args>(__args)...)`
     *  in C++11, C++14 and C++17. Changed in C++20 to call
     *  `std::construct_at(__p, std::forward<_Args>(__args)...)` instead.
    */
    template<typename _Up, typename... _Args>
static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
  _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
511#if __cplusplus201703L <= 201703L
 __a.construct(__p, std::forward<_Args>(__args)...);
12
←
Calling 'new_allocator::construct'→
23
←
Returning; memory was released via 2nd parameter→
513#else
 std::construct_at(__p, std::forward<_Args>(__args)...);
515#endif
}

    /**
     *  @brief  Destroy an object of type @a _Up
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the object to destroy
     *
     *  Calls @c __a.destroy(__p).
    */
    template<typename _Up>
static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
530#if __cplusplus201703L <= 201703L
 __a.destroy(__p);
532#else
 std::destroy_at(__p);
534#endif
}

    /**
     *  @brief  The maximum supported allocation size
     *  @param  __a  An allocator.
     *  @return @c __a.max_size()
    */
    static _GLIBCXX20_CONSTEXPR size_type
    max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
    {
545#if __cplusplus201703L <= 201703L
return __a.max_size();
547#else
return size_t(-1) / sizeof(value_type);
549#endif
    }

    /**
     *  @brief  Obtain an allocator to use when copying a container.
     *  @param  __rhs  An allocator.
     *  @return @c __rhs
    */
    static _GLIBCXX20_CONSTEXPR allocator_type
    select_on_container_copy_construction(const allocator_type& __rhs)
    { return __rhs; }
  };

562#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void
  __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
  { __one = __two; }

template<typename _Alloc>
  inline void
  __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
  { }
572#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_copy_assignment __pocca;
580#if __cplusplus201703L >= 201703L
    if constexpr (__pocca::value)
__one = __two;
583#else
    __do_alloc_on_copy(__one, __two, __pocca());
585#endif
  }

template<typename _Alloc>
  constexpr _Alloc
  __alloc_on_copy(const _Alloc& __a)
  {
    typedef allocator_traits<_Alloc> __traits;
    return __traits::select_on_container_copy_construction(__a);
  }

596#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
  { __one = std::move(__two); }

template<typename _Alloc>
  inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
  { }
604#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_move(_Alloc& __one, _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_move_assignment __pocma;
612#if __cplusplus201703L >= 201703L
    if constexpr (__pocma::value)
__one = std::move(__two);
615#else
    __do_alloc_on_move(__one, __two, __pocma());
617#endif
  }

620#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
  {
    using std::swap;
    swap(__one, __two);
  }

template<typename _Alloc>
  inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
  { }
631#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_swap(_Alloc& __one, _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_swap __pocs;
639#if __cplusplus201703L >= 201703L
    if constexpr (__pocs::value)
{
 using std::swap;
 swap(__one, __two);
}
645#else
    __do_alloc_on_swap(__one, __two, __pocs());
647#endif
  }

template<typename _Alloc, typename _Tp,
  typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
  typename = void>
  struct __is_alloc_insertable_impl
  : false_type
  { };

template<typename _Alloc, typename _Tp, typename _ValueT>
  struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
    __void_t<decltype(allocator_traits<_Alloc>::construct(
   std::declval<_Alloc&>(), std::declval<_ValueT*>(),
   std::declval<_Tp>()))>>
  : true_type
  { };

// true if _Alloc::value_type is CopyInsertable into containers using _Alloc
// (might be wrong if _Alloc::construct exists but is not constrained,
// i.e. actually trying to use it would still be invalid. Use with caution.)
template<typename _Alloc>
  struct __is_copy_insertable
  : __is_alloc_insertable_impl<_Alloc,
		 typename _Alloc::value_type const&>::type
  { };

// std::allocator<_Tp> just requires CopyConstructible
template<typename _Tp>
  struct __is_copy_insertable<allocator<_Tp>>
  : is_copy_constructible<_Tp>
  { };

// true if _Alloc::value_type is MoveInsertable into containers using _Alloc
// (might be wrong if _Alloc::construct exists but is not constrained,
// i.e. actually trying to use it would still be invalid. Use with caution.)
template<typename _Alloc>
  struct __is_move_insertable
  : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
  { };

// std::allocator<_Tp> just requires MoveConstructible
template<typename _Tp>
  struct __is_move_insertable<allocator<_Tp>>
  : is_move_constructible<_Tp>
  { };

// Trait to detect Allocator-like types.
template<typename _Alloc, typename = void>
  struct __is_allocator : false_type { };

template<typename _Alloc>
  struct __is_allocator<_Alloc,
    __void_t<typename _Alloc::value_type,
      decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
  : true_type { };

template<typename _Alloc>
  using _RequireAllocator
    = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

template<typename _Alloc>
  using _RequireNotAllocator
    = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
711#endif // C++11

/**
 * Destroy a range of objects using the supplied allocator.  For
 * non-default allocators we do not optimize away invocation of
 * destroy() even if _Tp has a trivial destructor.
 */

template<typename _ForwardIterator, typename _Allocator>
  void
  _Destroy(_ForwardIterator __first, _ForwardIterator __last,
    _Allocator& __alloc)
  {
    for (; __first != __last; ++__first)
725#if __cplusplus201703L < 201103L
__alloc.destroy(std::__addressof(*__first));
727#else
allocator_traits<_Allocator>::destroy(__alloc,
			      std::__addressof(*__first));
730#endif
  }

template<typename _ForwardIterator, typename _Tp>
  inline void
  _Destroy(_ForwardIterator __first, _ForwardIterator __last,
    allocator<_Tp>&)
  {
    _Destroy(__first, __last);
  }

741_GLIBCXX_END_NAMESPACE_VERSION
742} // namespace std
743#endif // _ALLOC_TRAITS_H

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/ext/new_allocator.h

→

1// Allocator that wraps operator new -*- C++ -*-
2 
3// Copyright (C) 2001-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.
10 
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.
15 
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.
19 
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/>.
24 
25/** @file ext/new_allocator.h
26 *  This file is a GNU extension to the Standard C++ Library.
27 */
28 
29#ifndef _NEW_ALLOCATOR_H1
30#define _NEW_ALLOCATOR_H1 1
31 
32#include <bits/c++config.h>
33#include <new>
34#include <bits/functexcept.h>
35#include <bits/move.h>
36#if __cplusplus201703L >= 201103L
37#include <type_traits>
38#endif
39 
40namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
41{
42_GLIBCXX_BEGIN_NAMESPACE_VERSION
43 
44  /**
45   *  @brief  An allocator that uses global new, as per [20.4].
46   *  @ingroup allocators
47   *
48   *  This is precisely the allocator defined in the C++ Standard.
49   *    - all allocation calls operator new
50   *    - all deallocation calls operator delete
51   *
52   *  @tparam  _Tp  Type of allocated object.
53   */
54  template<typename _Tp>
55    class new_allocator
56    {
57    public:
58      typedef _Tp        value_type;
59      typedef std::size_t     size_type;
60      typedef std::ptrdiff_t  difference_type;
61#if __cplusplus201703L <= 201703L
62      typedef _Tp*       pointer;
63      typedef const _Tp* const_pointer;
64      typedef _Tp&       reference;
65      typedef const _Tp& const_reference;
66 
67      template<typename _Tp1>
68	struct rebind
69	{ typedef new_allocator<_Tp1> other; };
70#endif
71 
72#if __cplusplus201703L >= 201103L
73      // _GLIBCXX_RESOLVE_LIB_DEFECTS
74      // 2103. propagate_on_container_move_assignment
75      typedef std::true_type propagate_on_container_move_assignment;
76#endif
77 
78      _GLIBCXX20_CONSTEXPR
79      new_allocator() _GLIBCXX_USE_NOEXCEPTnoexcept { }
80 
81      _GLIBCXX20_CONSTEXPR
82      new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPTnoexcept { }
83 
84      template<typename _Tp1>
85	_GLIBCXX20_CONSTEXPR
86	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPTnoexcept { }
87 
88#if __cplusplus201703L <= 201703L
89      ~new_allocator() _GLIBCXX_USE_NOEXCEPTnoexcept { }
90 
91      pointer
92      address(reference __x) const _GLIBCXX_NOEXCEPTnoexcept
93      { return std::__addressof(__x); }
94 
95      const_pointer
96      address(const_reference __x) const _GLIBCXX_NOEXCEPTnoexcept
97      { return std::__addressof(__x); }
98#endif
99 
100      // NB: __n is permitted to be 0.  The C++ standard says nothing
101      // about what the return value is when __n == 0.
102      _GLIBCXX_NODISCARD[[__nodiscard__]] _Tp*
103      allocate(size_type __n, const void* = static_cast<const void*>(0))
104      {
105	if (__n > this->_M_max_size())
106	  std::__throw_bad_alloc();
107 
108#if __cpp_aligned_new201606L
109	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__16UL)
110	  {
111	    std::align_val_t __al = std::align_val_t(alignof(_Tp));
112	    return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
113	  }
114#endif
115	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
116      }
117 
118      // __p is not permitted to be a null pointer.
119      void
120      deallocate(_Tp* __p, size_type __t)
121      {
122#if __cpp_aligned_new201606L
123	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__16UL)
124	  {
125	    ::operator delete(__p,
126# if __cpp_sized_deallocation
127			      __t * sizeof(_Tp),
128# endif
129			      std::align_val_t(alignof(_Tp)));
130	    return;
131	  }
132#endif
133	::operator delete(__p
134#if __cpp_sized_deallocation
135			  , __t * sizeof(_Tp)
136#endif
137			 );
138      }
139 
140#if __cplusplus201703L <= 201703L
141      size_type
142      max_size() const _GLIBCXX_USE_NOEXCEPTnoexcept
143      { return _M_max_size(); }
144 
145#if __cplusplus201703L >= 201103L
146      template<typename _Up, typename... _Args>
147	void
148	construct(_Up* __p, _Args&&... __args)
149	noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
150	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
13
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
14
←
Calling '~Reference'→
21
←
Returning from '~Reference'→
22
←
Returning from destructor for 'VclPtr<vcl::Window>'→
151 
152      template<typename _Up>
153	void
154	destroy(_Up* __p)
155	noexcept(std::is_nothrow_destructible<_Up>::value)
156	{ __p->~_Up(); }
157#else
158      // _GLIBCXX_RESOLVE_LIB_DEFECTS
159      // 402. wrong new expression in [some_] allocator::construct
160      void
161      construct(pointer __p, const _Tp& __val)
162      { ::new((void *)__p) _Tp(__val); }
163 
164      void
165      destroy(pointer __p) { __p->~_Tp(); }
166#endif
167#endif // ! C++20
168 
169      template<typename _Up>
170	friend _GLIBCXX20_CONSTEXPR bool
171	operator==(const new_allocator&, const new_allocator<_Up>&)
172	_GLIBCXX_NOTHROWnoexcept
173	{ return true; }
174 
175#if __cpp_impl_three_way_comparison < 201907L
176      template<typename _Up>
177	friend _GLIBCXX20_CONSTEXPR bool
178	operator!=(const new_allocator&, const new_allocator<_Up>&)
179	_GLIBCXX_NOTHROWnoexcept
180	{ return false; }
181#endif
182 
183    private:
184      _GLIBCXX_CONSTEXPRconstexpr size_type
185      _M_max_size() const _GLIBCXX_USE_NOEXCEPTnoexcept
186      {
187#if __PTRDIFF_MAX__9223372036854775807L < __SIZE_MAX__18446744073709551615UL
188	return std::size_t(__PTRDIFF_MAX__9223372036854775807L) / sizeof(_Tp);
189#else
190	return std::size_t(-1) / sizeof(_Tp);
191#endif
192      }
193    };
194 
195_GLIBCXX_END_NAMESPACE_VERSION
196} // namespace
197 
198#endif

←

/home/maarten/src/libreoffice/core/include/rtl/ref.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_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody14.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
15
←
Taking true branch→
33
←
Taking true branch→
          m_pBody->release();
16
←
Calling 'VclReferenceBase::release'→
20
←
Returning; memory was released→
34
←
Use of memory after it is freed
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
17
←
Assuming the condition is true→
18
←
Taking true branch→
40            delete this;
19
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif