/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx
Warning:	line 484, column 25 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name svdxcgv.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 SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -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/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -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/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -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/svx/source/svdraw/svdxcgv.cxx

/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx

→

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

20#include <vector>
21#include <unordered_set>
22#include <editeng/editdata.hxx>
23#include <rtl/strbuf.hxx>
24#include <svx/xfillit0.hxx>
25#include <svx/xlineit0.hxx>
26#include <svx/svdxcgv.hxx>
27#include <svx/svdoutl.hxx>
28#include <svx/svdundo.hxx>
29#include <svx/svdograf.hxx>
30#include <svx/svdoole2.hxx>
31#include <svx/svdorect.hxx>
32#include <svx/svdopage.hxx>
33#include <svx/svdpage.hxx>
34#include <svx/svdpagv.hxx>
35#include <svx/svdtrans.hxx>
36#include <svx/strings.hrc>
37#include <svx/dialmgr.hxx>
38#include <tools/bigint.hxx>
39#include <clonelist.hxx>
40#include <vcl/virdev.hxx>
41#include <svl/style.hxx>
42#include <fmobj.hxx>
43#include <vcl/vectorgraphicdata.hxx>
44#include <drawinglayer/primitive2d/groupprimitive2d.hxx>
45#include <drawinglayer/geometry/viewinformation2d.hxx>
46#include <svx/sdr/contact/viewcontact.hxx>
47#include <sdr/contact/objectcontactofobjlistpainter.hxx>
48#include <svx/sdr/contact/displayinfo.hxx>
49#include <svx/svdotable.hxx>
50#include <sal/log.hxx>

52using namespace com::sun::star;

54SdrExchangeView::SdrExchangeView(
  SdrModel& rSdrModel,
  OutputDevice* pOut)
  SdrObjEditView(rSdrModel, pOut)
58{
59}

61bool SdrExchangeView::ImpLimitToWorkArea(Point& rPt) const
62{
  bool bRet(false);

  if(!maMaxWorkArea.IsEmpty())
  {
      if(rPt.X()<maMaxWorkArea.Left())
      {
          rPt.setX( maMaxWorkArea.Left() );
          bRet = true;
      }

      if(rPt.X()>maMaxWorkArea.Right())
      {
          rPt.setX( maMaxWorkArea.Right() );
          bRet = true;
      }

      if(rPt.Y()<maMaxWorkArea.Top())
      {
          rPt.setY( maMaxWorkArea.Top() );
          bRet = true;
      }

      if(rPt.Y()>maMaxWorkArea.Bottom())
      {
          rPt.setY( maMaxWorkArea.Bottom() );
          bRet = true;
      }
  }
  return bRet;
92}

94void SdrExchangeView::ImpGetPasteObjList(Point& /*rPos*/, SdrObjList*& rpLst)
95{
  if (rpLst==nullptr)
  {
      SdrPageView* pPV = GetSdrPageView();

      if (pPV!=nullptr) {
          rpLst=pPV->GetObjList();
      }
  }
104}

106bool SdrExchangeView::ImpGetPasteLayer(const SdrObjList* pObjList, SdrLayerID& rLayer) const
107{
  bool bRet=false;
  rLayer=SdrLayerID(0);
  if (pObjList!=nullptr) {
      const SdrPage* pPg=pObjList->getSdrPageFromSdrObjList();
      if (pPg!=nullptr) {
          rLayer=pPg->GetLayerAdmin().GetLayerID(maActualLayer);
          if (rLayer==SDRLAYER_NOTFOUND) rLayer=SdrLayerID(0);
          SdrPageView* pPV = GetSdrPageView();
          if (pPV!=nullptr) {
              bRet=!pPV->GetLockedLayers().IsSet(rLayer) && pPV->GetVisibleLayers().IsSet(rLayer);
          }
      }
  }
  return bRet;
122}

124bool SdrExchangeView::Paste(const OUString& rStr, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions)
125{
  if (rStr.isEmpty())
      return false;

  Point aPos(rPos);
  ImpGetPasteObjList(aPos,pLst);
  ImpLimitToWorkArea( aPos );
  if (pLst==nullptr) return false;
  SdrLayerID nLayer;
  if (!ImpGetPasteLayer(pLst,nLayer)) return false;
  bool bUnmark = (nOptions & (SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit();
  if (bUnmark) UnmarkAllObj();
  tools::Rectangle aTextRect(0,0,500,500);
  SdrPage* pPage=pLst->getSdrPageFromSdrObjList();
  if (pPage!=nullptr) {
      aTextRect.SetSize(pPage->GetSize());
  }
  SdrRectObj* pObj = new SdrRectObj(
      getSdrModelFromSdrView(),
      OBJ_TEXT,
      aTextRect);

  pObj->SetLayer(nLayer);
  pObj->NbcSetText(rStr); // SetText before SetAttr, else SetAttr doesn't work!
  if (mpDefaultStyleSheet!=nullptr) pObj->NbcSetStyleSheet(mpDefaultStyleSheet, false);

  pObj->SetMergedItemSet(maDefaultAttr);

  SfxItemSet aTempAttr(mpModel->GetItemPool());  // no fill, no line
  aTempAttr.Put(XLineStyleItem(drawing::LineStyle_NONE));
  aTempAttr.Put(XFillStyleItem(drawing::FillStyle_NONE));

  pObj->SetMergedItemSet(aTempAttr);

  pObj->FitFrameToTextSize();
  Size aSiz(pObj->GetLogicRect().GetSize());
  MapUnit eMap=mpModel->GetScaleUnit();
  Fraction aMap=mpModel->GetScaleFraction();
  ImpPasteObject(pObj,*pLst,aPos,aSiz,MapMode(eMap,Point(0,0),aMap,aMap),nOptions);
  return true;
165}

167bool SdrExchangeView::Paste(SvStream& rInput, EETextFormat eFormat, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions)
168{
  Point aPos(rPos);
  ImpGetPasteObjList(aPos,pLst);
  ImpLimitToWorkArea( aPos );
  if (pLst==nullptr) return false;
  SdrLayerID nLayer;
  if (!ImpGetPasteLayer(pLst,nLayer)) return false;
  bool bUnmark=(nOptions&(SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit();
  if (bUnmark) UnmarkAllObj();
  tools::Rectangle aTextRect(0,0,500,500);
  SdrPage* pPage=pLst->getSdrPageFromSdrObjList();
  if (pPage!=nullptr) {
      aTextRect.SetSize(pPage->GetSize());
  }
  SdrRectObj* pObj = new SdrRectObj(
      getSdrModelFromSdrView(),
      OBJ_TEXT,
      aTextRect);

  pObj->SetLayer(nLayer);
  if (mpDefaultStyleSheet!=nullptr) pObj->NbcSetStyleSheet(mpDefaultStyleSheet, false);

  pObj->SetMergedItemSet(maDefaultAttr);

  SfxItemSet aTempAttr(mpModel->GetItemPool());  // no fill, no line
  aTempAttr.Put(XLineStyleItem(drawing::LineStyle_NONE));
  aTempAttr.Put(XFillStyleItem(drawing::FillStyle_NONE));

  pObj->SetMergedItemSet(aTempAttr);

  pObj->NbcSetText(rInput,OUString(),eFormat);
  pObj->FitFrameToTextSize();
  Size aSiz(pObj->GetLogicRect().GetSize());
  MapUnit eMap=mpModel->GetScaleUnit();
  Fraction aMap=mpModel->GetScaleFraction();
  ImpPasteObject(pObj,*pLst,aPos,aSiz,MapMode(eMap,Point(0,0),aMap,aMap),nOptions);

  // b4967543
  if(pObj->GetOutlinerParaObject())
  {
      SdrOutliner& rOutliner = pObj->getSdrModelFromSdrObject().GetHitTestOutliner();
      rOutliner.SetText(*pObj->GetOutlinerParaObject());

      if(1 == rOutliner.GetParagraphCount())
      {
          SfxStyleSheet* pCandidate = rOutliner.GetStyleSheet(0);

          if(pCandidate)
          {
              if(pObj->getSdrModelFromSdrObject().GetStyleSheetPool() == pCandidate->GetPool())
              {
                  pObj->NbcSetStyleSheet(pCandidate, true);
              }
          }
      }
  }

  return true;
226}

228bool SdrExchangeView::Paste(
  const SdrModel& rMod, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions)
230{
  const SdrModel* pSrcMod=&rMod;
  if (pSrcMod==mpModel)
      return false; // this can't work, right?

  const bool bUndo = IsUndoEnabled();

  if( bUndo )
      BegUndo(SvxResId(STR_ExchangePastereinterpret_cast<char const *>("STR_ExchangePaste" "\004"
 u8"Insert object(s)")));

  if( mxSelectionController.is() && mxSelectionController->PasteObjModel( rMod ) )
  {
      if( bUndo )
          EndUndo();
      return true;
  }

  Point aPos(rPos);
  ImpGetPasteObjList(aPos,pLst);
  SdrPageView* pMarkPV=nullptr;
  SdrPageView* pPV = GetSdrPageView();

  if(pPV && pPV->GetObjList() == pLst )
      pMarkPV=pPV;

  ImpLimitToWorkArea( aPos );
  if (pLst==nullptr)
      return false;

  bool bUnmark=(nOptions&(SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit();
  if (bUnmark)
      UnmarkAllObj();

  // Rescale, if the Model uses a different MapUnit.
  // Calculate the necessary factors first.
  MapUnit eSrcUnit=pSrcMod->GetScaleUnit();
  MapUnit eDstUnit=mpModel->GetScaleUnit();
  bool bResize=eSrcUnit!=eDstUnit;
  Fraction aXResize,aYResize;
  Point aPt0;
  if (bResize)
  {
      FrPair aResize(GetMapFactor(eSrcUnit,eDstUnit));
      aXResize=aResize.X();
      aYResize=aResize.Y();
  }
  SdrObjList*  pDstLst=pLst;
  sal_uInt16 nPg,nPgCount=pSrcMod->GetPageCount();
  for (nPg=0; nPg<nPgCount; nPg++)
  {
      const SdrPage* pSrcPg=pSrcMod->GetPage(nPg);

      // Use SnapRect, not BoundRect here
      tools::Rectangle aR=pSrcPg->GetAllObjSnapRect();

      if (bResize)
          ResizeRect(aR,aPt0,aXResize,aYResize);
      Point aDist(aPos-aR.Center());
      Size  aSiz(aDist.X(),aDist.Y());
      size_t nCloneErrCnt = 0;
      const size_t nObjCount = pSrcPg->GetObjCount();
      bool bMark = pMarkPV!=nullptr && !IsTextEdit() && (nOptions&SdrInsertFlags::DONTMARK)==SdrInsertFlags::NONE;

      // #i13033#
      // New mechanism to re-create the connections of cloned connectors
      CloneList aCloneList;
      std::unordered_set<rtl::OUString> aNameSet;
      for (size_t nOb=0; nOb<nObjCount; ++nOb)
      {
          const SdrObject* pSrcOb=pSrcPg->GetObj(nOb);

          SdrObject* pNewObj(pSrcOb->CloneSdrObject(*mpModel));

          if (pNewObj!=nullptr)
          {
              if(bResize)
              {
                  pNewObj->getSdrModelFromSdrObject().SetPasteResize(true);
                  pNewObj->NbcResize(aPt0,aXResize,aYResize);
                  pNewObj->getSdrModelFromSdrObject().SetPasteResize(false);
              }

              // #i39861#
              pNewObj->NbcMove(aSiz);

              const SdrPage* pPg = pDstLst->getSdrPageFromSdrObjList();

              if(pPg)
              {
                  // #i72535#
                  const SdrLayerAdmin& rAd = pPg->GetLayerAdmin();
                  SdrLayerID nLayer(0);

                  if(dynamic_cast<const FmFormObj*>( pNewObj) !=  nullptr)
                  {
                      // for FormControls, force to form layer
                      nLayer = rAd.GetLayerID(rAd.GetControlLayerName());
                  }
                  else
                  {
                      nLayer = rAd.GetLayerID(maActualLayer);
                  }

                  if(SDRLAYER_NOTFOUND == nLayer)
                  {
                      nLayer = SdrLayerID(0);
                  }

                  pNewObj->SetLayer(nLayer);
              }

              pDstLst->InsertObjectThenMakeNameUnique(pNewObj, aNameSet);

              if( bUndo )
                  AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoNewObject(*pNewObj));

              if (bMark) {
                  // Don't already set Markhandles!
                  // That is instead being done by ModelHasChanged in MarkView.
                  MarkObj(pNewObj,pMarkPV,false,true);
              }

              // #i13033#
              aCloneList.AddPair(pSrcOb, pNewObj);
          }
          else
          {
              nCloneErrCnt++;
          }
      }

      // #i13033#
      // New mechanism to re-create the connections of cloned connectors
      aCloneList.CopyConnections();

      if(0 != nCloneErrCnt)
      {
367#ifdef DBG_UTIL
          OStringBuffer aStr("SdrExchangeView::Paste(): Error when cloning ");

          if(nCloneErrCnt == 1)
          {
              aStr.append("a drawing object.");
          }
          else
          {
              aStr.append(static_cast<sal_Int32>(nCloneErrCnt));
              aStr.append(" drawing objects.");
          }

          aStr.append(" Not copying object connectors.");

          OSL_FAIL(aStr.getStr())do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx"
 ":" "382" ": "), "%s", aStr.getStr()); } } while (false);
383#endif
      }
  }

  if( bUndo )
      EndUndo();

  return true;
391}

393void SdrExchangeView::ImpPasteObject(SdrObject* pObj, SdrObjList& rLst, const Point& rCenter, const Size& rSiz, const MapMode& rMap, SdrInsertFlags nOptions)
394{
  BigInt nSizX(rSiz.Width());
  BigInt nSizY(rSiz.Height());
  MapUnit eSrcMU=rMap.GetMapUnit();
  MapUnit eDstMU=mpModel->GetScaleUnit();
  FrPair aMapFact(GetMapFactor(eSrcMU,eDstMU));
  Fraction aDstFr(mpModel->GetScaleFraction());
  nSizX *= double(aMapFact.X() * rMap.GetScaleX() * aDstFr);
  nSizX *= aDstFr.GetDenominator();
  nSizY *= double(aMapFact.Y() * rMap.GetScaleY());
  nSizY /= aDstFr.GetNumerator();
  long xs=nSizX;
  long ys=nSizY;
  Point aPos(rCenter.X()-xs/2,rCenter.Y()-ys/2);
  tools::Rectangle aR(aPos.X(),aPos.Y(),aPos.X()+xs,aPos.Y()+ys);
  pObj->SetLogicRect(aR);
  rLst.InsertObject(pObj, SAL_MAX_SIZE((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));

  if( IsUndoEnabled() )
      AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoNewObject(*pObj));

  SdrPageView* pMarkPV=nullptr;
  SdrPageView* pPV = GetSdrPageView();

  if(pPV && pPV->GetObjList()==&rLst)
      pMarkPV=pPV;

  bool bMark = pMarkPV!=nullptr && !IsTextEdit() && (nOptions&SdrInsertFlags::DONTMARK)==SdrInsertFlags::NONE;
  if (bMark)
  { // select object the first PageView we found
      MarkObj(pObj,pMarkPV);
  }
426}

428BitmapEx SdrExchangeView::GetMarkedObjBitmapEx(bool bNoVDevIfOneBmpMarked) const
429{
  BitmapEx aBmp;

  if( AreObjectsMarked() )
1
Calling 'SdrMarkView::AreObjectsMarked'→
4
←
Returning from 'SdrMarkView::AreObjectsMarked'→
5
←
Taking true branch→
  {
      if(1 == GetMarkedObjectCount())
6
←
Assuming the condition is false→
7
←
Taking false branch→
      {
          if(bNoVDevIfOneBmpMarked)
          {
              SdrObject*  pGrafObjTmp = GetMarkedObjectByIndex( 0 );
              SdrGrafObj* pGrafObj = dynamic_cast<SdrGrafObj*>( pGrafObjTmp  );

              if( pGrafObj && ( pGrafObj->GetGraphicType() == GraphicType::Bitmap ) )
              {
                  aBmp = pGrafObj->GetTransformedGraphic().GetBitmapEx();
              }
          }
          else
          {
              const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(GetMarkedObjectByIndex(0));

              if(pSdrGrafObj && pSdrGrafObj->isEmbeddedVectorGraphicData())
              {
                  aBmp = pSdrGrafObj->GetGraphic().getVectorGraphicData()->getReplacement();
              }
          }
      }

      if( !aBmp )
8
←
Calling 'BitmapEx::operator!'→
21
←
Returning from 'BitmapEx::operator!'→
22
←
Taking true branch→
      {
          // choose conversion directly using primitives to bitmap to avoid
          // rendering errors with tiled bitmap fills (these will be tiled in a
          // in-between metafile, but tend to show 'gaps' since the target is *no*
          // bitmap rendering)
          ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects());
          const sal_uInt32 nCount(aSdrObjects.size());

          if(nCount)
23
←
Assuming 'nCount' is not equal to 0→
24
←
Taking true branch→
          {
              // collect sub-primitives as group objects, thus no expensive append
              // to existing sequence is needed
              drawinglayer::primitive2d::Primitive2DContainer xPrimitives(nCount);

              for(sal_uInt32 a(0); a24.1
'a' is < 'nCount'
1
'a' is < 'nCount'
1
'a' is < 'nCount'
1
'a' is < 'nCount'
1
'a' is < 'nCount'
1
'a' is < 'nCount'
 < nCount; a++)
25
←
Loop condition is true.  Entering loop body→
              {
                  SdrObject* pCandidate = aSdrObjects[a];
26
←
'pCandidate' initialized here→
                  SdrGrafObj* pSdrGrafObj = dynamic_cast< SdrGrafObj* >(pCandidate);

                  if(pSdrGrafObj)
27
←
Assuming 'pSdrGrafObj' is null→
28
←
Taking false branch→
                  {
                      // #122753# To ensure existence of graphic content, force swap in
                      pSdrGrafObj->ForceSwapIn();
                  }

                  xPrimitives[a] = new drawinglayer::primitive2d::GroupPrimitive2D(
                      pCandidate->GetViewContact().getViewIndependentPrimitive2DContainer());
29
←
Called C++ object pointer is null
              }

              // get logic range
              const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
              const basegfx::B2DRange aRange(xPrimitives.getB2DRange(aViewInformation2D));

              if(!aRange.isEmpty())
              {
                  // if we have geometry and it has a range, convert to BitmapEx using
                  // common tooling
                  aBmp = convertPrimitive2DSequenceToBitmapEx(
                      xPrimitives,
                      aRange);
              }
          }
      }
  }

  return aBmp;
504}


507GDIMetaFile SdrExchangeView::GetMarkedObjMetaFile(bool bNoVDevIfOneMtfMarked) const
508{
  GDIMetaFile aMtf;

  if( AreObjectsMarked() )
  {
      tools::Rectangle   aBound( GetMarkedObjBoundRect() );
      Size        aBoundSize( aBound.GetWidth(), aBound.GetHeight() );
      MapMode     aMap( mpModel->GetScaleUnit(), Point(), mpModel->GetScaleFraction(), mpModel->GetScaleFraction() );

      if( bNoVDevIfOneMtfMarked )
      {
          SdrObject*  pGrafObjTmp = GetMarkedObjectByIndex( 0 );
          SdrGrafObj* pGrafObj = ( GetMarkedObjectCount() ==1 ) ? dynamic_cast<SdrGrafObj*>( pGrafObjTmp  ) : nullptr;

          if( pGrafObj )
          {
              Graphic aGraphic( pGrafObj->GetTransformedGraphic() );

              // #119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically
              aMtf = aGraphic.GetGDIMetaFile();
          }
      }

      if( !aMtf.GetActionSize() )
      {
          ScopedVclPtrInstance< VirtualDevice > pOut;
          const Size aDummySize(2, 2);

          pOut->SetOutputSizePixel(aDummySize);
          pOut->EnableOutput(false);
          pOut->SetMapMode(aMap);
          aMtf.Clear();
          aMtf.Record(pOut);

          DrawMarkedObj(*pOut);

          aMtf.Stop();
          aMtf.WindStart();

          // moving the result is more reliable then setting a relative MapMode at the VDev (used
          // before), also see #i99268# in GetObjGraphic() below. Some draw actions at
          // the OutDev are simply not handled correctly when a MapMode is set at the
          // target device, e.g. MetaFloatTransparentAction. Even the Move for this action
          // was missing the manipulation of the embedded Metafile
          aMtf.Move(-aBound.Left(), -aBound.Top());

          aMtf.SetPrefMapMode( aMap );

          // removed PrefSize extension. It is principally wrong to set a reduced size at
          // the created MetaFile. The mentioned errors occur at output time since the integer
          // MapModes from VCL lead to errors. It is now corrected in the VCLRenderer for
          // primitives (and may later be done in breaking up a MetaFile to primitives)
          aMtf.SetPrefSize(aBoundSize);
      }
  }

  return aMtf;
565}


568Graphic SdrExchangeView::GetAllMarkedGraphic() const
569{
  Graphic aRet;

  if( AreObjectsMarked() )
  {
      if( ( 1 == GetMarkedObjectCount() ) && GetSdrMarkByIndex( 0 ) )
          aRet = SdrExchangeView::GetObjGraphic(*GetMarkedObjectByIndex(0));
      else
          aRet = GetMarkedObjMetaFile();
  }

  return aRet;
581}


584Graphic SdrExchangeView::GetObjGraphic(const SdrObject& rSdrObject)
585{
  Graphic aRet;

  // try to get a graphic from the object first
  const SdrGrafObj* pSdrGrafObj(dynamic_cast< const SdrGrafObj* >(&rSdrObject));
  const SdrOle2Obj* pSdrOle2Obj(dynamic_cast< const SdrOle2Obj* >(&rSdrObject));

  if(pSdrGrafObj)
  {
      if(pSdrGrafObj->isEmbeddedVectorGraphicData())
      {
          // get Metafile for Svg content
          aRet = pSdrGrafObj->getMetafileFromEmbeddedVectorGraphicData();
      }
      else
      {
          // Make behaviour coherent with metafile
          // recording below (which of course also takes
          // view-transformed objects)
          aRet = pSdrGrafObj->GetTransformedGraphic();
      }
  }
  else if(pSdrOle2Obj)
  {
      if(pSdrOle2Obj->GetGraphic())
      {
          aRet = *pSdrOle2Obj->GetGraphic();
      }
  }

  // if graphic could not be retrieved => go the hard way and create a MetaFile
  if((GraphicType::NONE == aRet.GetType()) || (GraphicType::Default == aRet.GetType()))
  {
      ScopedVclPtrInstance< VirtualDevice > pOut;
      GDIMetaFile aMtf;
      const tools::Rectangle aBoundRect(rSdrObject.GetCurrentBoundRect());
      const MapMode aMap(rSdrObject.getSdrModelFromSdrObject().GetScaleUnit(),
          Point(),
          rSdrObject.getSdrModelFromSdrObject().GetScaleFraction(),
          rSdrObject.getSdrModelFromSdrObject().GetScaleFraction());

      pOut->EnableOutput(false);
      pOut->SetMapMode(aMap);
      aMtf.Record(pOut);
      rSdrObject.SingleObjectPainter(*pOut);
      aMtf.Stop();
      aMtf.WindStart();

      // #i99268# replace the original offset from using XOutDev's SetOffset
      // NOT (as tried with #i92760#) with another MapMode which gets recorded
      // by the Metafile itself (what always leads to problems), but by
      // moving the result directly
      aMtf.Move(-aBoundRect.Left(), -aBoundRect.Top());
      aMtf.SetPrefMapMode(aMap);
      aMtf.SetPrefSize(aBoundRect.GetSize());

      if(aMtf.GetActionSize())
      {
          aRet = aMtf;
      }
  }

  return aRet;
648}


:std::vector< SdrObject* > SdrExchangeView::GetMarkedObjects() const
652{
  SortMarkedObjects();
  ::std::vector< SdrObject* > aRetval;

  ::std::vector< ::std::vector< SdrMark* > >  aObjVectors( 2 );
  ::std::vector< SdrMark* >&                  rObjVector1 = aObjVectors[ 0 ];
  ::std::vector< SdrMark* >&                  rObjVector2 = aObjVectors[ 1 ];
  const SdrLayerAdmin&                        rLayerAdmin = mpModel->GetLayerAdmin();
  const SdrLayerID                            nControlLayerId = rLayerAdmin.GetLayerID( rLayerAdmin.GetControlLayerName() );

  for( size_t n = 0, nCount = GetMarkedObjectCount(); n < nCount; ++n )
  {
      SdrMark* pMark = GetSdrMarkByIndex( n );

      // paint objects on control layer on top of all other objects
      if( nControlLayerId == pMark->GetMarkedSdrObj()->GetLayer() )
          rObjVector2.push_back( pMark );
      else
          rObjVector1.push_back( pMark );
  }

  for(const std::vector<SdrMark*> & rObjVector : aObjVectors)
  {
      for(SdrMark* pMark : rObjVector)
      {
          aRetval.push_back(pMark->GetMarkedSdrObj());
      }
  }

  return aRetval;
682}


685void SdrExchangeView::DrawMarkedObj(OutputDevice& rOut) const
686{
  ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects());

  if(!aSdrObjects.empty())
  {
      sdr::contact::ObjectContactOfObjListPainter aPainter(rOut, aSdrObjects, aSdrObjects[0]->getSdrPageFromSdrObject());
      sdr::contact::DisplayInfo aDisplayInfo;

      // do processing
      aPainter.ProcessDisplay(aDisplayInfo);
  }
697}

699std::unique_ptr<SdrModel> SdrExchangeView::CreateMarkedObjModel() const
700{
  // Sorting the MarkList here might be problematic in the future, so
  // use a copy.
  SortMarkedObjects();
  std::unique_ptr<SdrModel> pNewModel(mpModel->AllocModel());
  SdrPage* pNewPage(pNewModel->AllocPage(false));
  pNewModel->InsertPage(pNewPage);
  ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects());

  // #i13033#
  // New mechanism to re-create the connections of cloned connectors
  CloneList aCloneList;

  for(SdrObject* pObj : aSdrObjects)
  {
      SdrObject* pNewObj(nullptr);

      if(nullptr != dynamic_cast< const SdrPageObj* >(pObj))
      {
          // convert SdrPageObj's to a graphic representation, because
          // virtual connection to referenced page gets lost in new model
          pNewObj = new SdrGrafObj(
              *pNewModel,
              GetObjGraphic(*pObj),
              pObj->GetLogicRect());
      }
      else if(nullptr != dynamic_cast< const sdr::table::SdrTableObj* >(pObj))
      {
          // check if we have a valid selection *different* from whole table
          // being selected
          if(mxSelectionController.is())
          {
              pNewObj = mxSelectionController->GetMarkedSdrObjClone(*pNewModel);
          }
      }

      if(nullptr == pNewObj)
      {
          // not cloned yet
          if(pObj->GetObjIdentifier() == OBJ_OLE2 && nullptr == mpModel->GetPersist())
          {
              // tdf#125520 - former fix was wrong, the SdrModel
              // has to have a GetPersist() already, see task.
              // We can still warn here when this is not the case
              SAL_WARN( "svx", "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx"
 ":" "744" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"),
 ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx"
 ":" "744" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx"
 ":" "744" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"),
 ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdxcgv.cxx"
 ":" "744" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }

          // use default way
          pNewObj = pObj->CloneSdrObject(*pNewModel);
      }

      if(pNewObj)
      {
          pNewPage->InsertObject(pNewObj, SAL_MAX_SIZE((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));

          // #i13033#
          aCloneList.AddPair(pObj, pNewObj);
      }
  }

  // #i13033#
  // New mechanism to re-create the connections of cloned connectors
  aCloneList.CopyConnections();

  return pNewModel;
765}

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

←

/home/maarten/src/libreoffice/core/include/svx/svdmrkv.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_SVX_SVDMRKV_HXX
21#define INCLUDED_SVX_SVDMRKV_HXX

23#include <svx/svdmark.hxx>
24#include <svx/svdhdl.hxx>
25#include <svx/svdsnpv.hxx>
26#include <svx/svdtypes.hxx>
27#include <svx/svxdllapi.h>
28#include <o3tl/typed_flags_set.hxx>
29#include <basegfx/range/b2drectangle.hxx>


32class SfxViewShell;

34// The following is not yet implemented, or just partially:
35enum class SdrSearchOptions
36{
  NONE         = 0x0000,
  DEEP         = 0x0001, /* recursive into group objects */
  ALSOONMASTER = 0x0002, /* MasterPages are also scanned */
  WHOLEPAGE    = 0x0004, /* Not just the ObjList of PageView */
  TESTMARKABLE = 0x0008, /* just markable objects/points/handles/... */
  TESTMACRO    = 0x0010, /* Just objects with macro */
  TESTTEXTEDIT = 0x0020, /* Just TextEdit-enabled objects */
  MARKED       = 0x0040, /* Just marked objects/points/... */
  PASS2BOUND   = 0x0080, /* In case of empty search results, then 2nd. try with BoundRectHit */
  BEFOREMARK   = 0x0100, /* if one marked one found, ignore all behind that */

  IMPISMASTER  = 0x0200, /* MasterPage is being searched right now */
  PICKMARKABLE = TESTMARKABLE,
  PICKTEXTEDIT = DEEP | TESTMARKABLE | TESTTEXTEDIT,
  PICKMACRO    = DEEP | ALSOONMASTER | WHOLEPAGE | TESTMACRO,
52};
53namespace o3tl
54{
  template<> struct typed_flags<SdrSearchOptions> : is_typed_flags<SdrSearchOptions, 0x03ff> {};
56}

58enum class SdrHitKind
59{
  NONE,            // No hit
  Object,          // Hit
  Handle,          // Marking handle
  HelpLine,        // Reference line
  Gluepoint,       // Glue point
  TextEdit,        // Open OutlinerView was hit
  TextEditObj,     // Object for SdrBeginTextEdit (Textbereich)
  UrlField,        // Field in TextObj was hit (while it is currently not edited)
  Macro,           // Object for BegMacroObj
  MarkedObject,    // Marked object (e.g. for dragging)
  UnmarkedObject,  // non-marked Object (e.g. for marking)
  Cell             // hit on a cell inside a table shape (outside of the cells text area)
72};

74enum class SdrViewEditMode {
  Edit,           // Also known as arrow or pointer mode
  Create,         // Tool for object creation
  GluePointEdit   // Glue point editing mode
78};

80/** options for ImpGetDescriptionString() */
81enum class ImpGetDescriptionOptions
82{
  NONE       = 0,
  POINTS     = 1,
  GLUEPOINTS = 2,
86};

88class ImplMarkingOverlay;
89class MarkingSubSelectionOverlay;

91class SVXCORE_DLLPUBLIC__attribute__ ((visibility("default"))) SdrMarkView : public SdrSnapView
92{
  friend class                SdrPageView;

  // #114409#-3 Migrate selections
  std::unique_ptr<ImplMarkingOverlay> mpMarkObjOverlay;
  std::unique_ptr<ImplMarkingOverlay> mpMarkPointsOverlay;
  std::unique_ptr<ImplMarkingOverlay> mpMarkGluePointsOverlay;

  std::unique_ptr<MarkingSubSelectionOverlay> mpMarkingSubSelectionOverlay;

102protected:
  SdrObject*                  mpMarkedObj;       // If not just one object ( i.e. More than one object ) is marked.
  SdrPageView*                mpMarkedPV;        // If all marked objects are situated on the same PageView.

  Point                       maRef1;            // Persistent - Rotation center / axis of reflection
  Point                       maRef2;            // Persistent
  SdrHdlList                  maHdlList;

  sdr::ViewSelection          maSdrViewSelection;

  std::vector<basegfx::B2DRectangle> maSubSelectionList;
  tools::Rectangle            maMarkedObjRect;
  tools::Rectangle            maMarkedPointsRect;
  tools::Rectangle            maMarkedGluePointsRect;

  static constexpr sal_uInt16 mnFrameHandlesLimit = 50;

  SdrDragMode                 meDragMode;      // Persistent
  SdrViewEditMode             meEditMode;      // Persistent
  SdrViewEditMode             meEditMode0;     // Persistent

  bool                        mbDesignMode : 1;          // DesignMode for SdrUnoObj
  bool                        mbForceFrameHandles : 1;   // Persistent - FrameDrag also for single objects
  bool                        mbPlusHdlAlways : 1;       // Persistent
  bool                        mbInsPolyPoint : 1;        // at this time InsPolyPointDragging
  bool                        mbMarkedObjRectDirty : 1;
  bool                        mbMrkPntDirty : 1;
  bool                        mbMarkedPointsRectsDirty : 1;

  // flag to completely disable handles at the view
  bool                        mbMarkHandlesHidden : 1;

  // Helper to get a possible GridOffset from SdrObject
  bool getPossibleGridOffsetForSdrObject(
      basegfx::B2DVector& rOffset,
      const SdrObject* pObj,
      const SdrPageView* pPV) const;

  // Helper to get a possible GridOffset from Position
  bool getPossibleGridOffsetForPosition(
      basegfx::B2DVector& rOffset,
      const basegfx::B2DPoint& rPoint,
      const SdrPageView* pPV) const;

146private:
  SVX_DLLPRIVATE__attribute__ ((visibility("hidden"))) void ImpSetPointsRects() const;
  void UndirtyMrkPnt() const;

  void SetMarkHandlesForLOKit(tools::Rectangle const & rRect, const SfxViewShell* pOtherShell);

152protected:
  virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override;
  virtual void ModelHasChanged() override; // Is called by the PaintView
  virtual void SetMarkHandles(SfxViewShell* pOtherShell); // maHdlList - fill (List of handles)
  void         SetMarkRects();                                             // Rects at the PageViews
  void         CheckMarked();                                              // Scan MarkList after Del and Lock Layer ...
  void         AddDragModeHdl(SdrDragMode eMode);
  virtual bool MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) override;
  virtual bool RequestHelp(const HelpEvent& rHEvt) override;

  // add custom handles (used by other apps, e.g. AnchorPos)
  virtual void AddCustomHdl();

  void ForceRefToMarked();
  void ForceUndirtyMrkPnt() const                                       { if (mbMrkPntDirty) UndirtyMrkPnt(); }

  virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay) const;
  SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj) const;
  SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj,const SdrMarkList * pMarkList) const;
  bool ImpIsFrameHandles() const;
  OUString ImpGetDescriptionString(const char* pStrCacheID, ImpGetDescriptionOptions nOpt=ImpGetDescriptionOptions::NONE) const;

  // Generates a string including degrees symbol, from an angel specification in 1/100deg
  bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark);
  virtual bool MarkPoints(const tools::Rectangle* pRect, bool bUnmark);
  bool MarkGluePoints(const tools::Rectangle* pRect, bool bUnmark);

  void SetMoveOutside(bool bOn);
  bool MarkableObjectsExceed( int n ) const;

182protected:
  // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
  SdrMarkView(
      SdrModel& rSdrModel,
      OutputDevice* pOut);

  virtual ~SdrMarkView() override;

190public:
  virtual bool IsAction() const override;
  virtual void MovAction(const Point& rPnt) override;
  virtual void EndAction() override;
  virtual void BckAction() override;
  virtual void BrkAction() override;
  virtual void TakeActionRect(tools::Rectangle& rRect) const override;

  virtual void ClearPageView() override;
  virtual void HideSdrPage() override;
  bool IsObjMarkable(SdrObject const * pObj, SdrPageView const * pPV) const;

  // Returns sal_True if objects, points or glue points are selected by drawing a frame
  // (as long as the frame is drawn).
  bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); }

  // Marking objects by drawing of a selection frame
  void BegMarkObj(const Point& rPnt, bool bUnmark = false);
  void MovMarkObj(const Point& rPnt);
  bool EndMarkObj();
  void BrkMarkObj();
  bool IsMarkObj() const { return (nullptr != mpMarkObjOverlay); }

  // DragModes: SDRDRAG_CREATE,SdrDragMode::Move,SdrDragMode::Resize,SdrDragMode::Rotate,SdrDragMode::Mirror,SdrDragMode::Shear,SdrDragMode::Crook
  // Move==Resize
  // The interface might maybe be changed in the future because of Ortho-Drag
  void SetDragMode(SdrDragMode eMode);
  SdrDragMode GetDragMode() const { return meDragMode; }
  void SetFrameHandles(bool bOn);
  bool IsFrameHandles() const { return mbForceFrameHandles; }

  // returns true if number of markable objects is greater than 1
  bool HasMultipleMarkableObjects() const { return MarkableObjectsExceed(1); };

  void SetEditMode(SdrViewEditMode eMode);
  SdrViewEditMode GetEditMode() const { return meEditMode; }

  void SetEditMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::Edit:SdrViewEditMode::Create); }
  bool IsEditMode() const { return meEditMode==SdrViewEditMode::Edit; }
  void SetCreateMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::Create:SdrViewEditMode::Edit); }
  bool IsCreateMode() const { return meEditMode==SdrViewEditMode::Create; }
  void SetGluePointEditMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::GluePointEdit:meEditMode0); }
  bool IsGluePointEditMode() const { return meEditMode==SdrViewEditMode::GluePointEdit; }

  void SetDesignMode(bool bOn = true);
  bool IsDesignMode() const { return mbDesignMode; }

  void SetFrameDragSingles(bool bOn=true) { SetFrameHandles(bOn); }
  bool IsFrameDragSingles() const { return IsFrameHandles(); }

  bool HasMarkableObj() const { return MarkableObjectsExceed(0); };


243// migrate selections

245protected:
  // all available changing methods
  SdrMarkList& GetMarkedObjectListWriteAccess() { return maSdrViewSelection.GetMarkedObjectListWriteAccess(); }

249public:
  // all available const methods for read access to selection
  const SdrMarkList& GetMarkedObjectList() const { return maSdrViewSelection.GetMarkedObjectList(); }
  // returns SAL_MAX_SIZE if not found
  size_t TryToFindMarkedObject(const SdrObject* pObj) const { return GetMarkedObjectList().FindObject(pObj); }
  SdrPageView* GetSdrPageViewOfMarkedByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetPageView(); }
  SdrMark* GetSdrMarkByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum); }
  SdrObject* GetMarkedObjectByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetMarkedSdrObj(); }
  size_t GetMarkedObjectCount() const { return GetMarkedObjectList().GetMarkCount(); }
  void SortMarkedObjects() const { GetMarkedObjectList().ForceSort(); }
  bool AreObjectsMarked() const { return 0 != GetMarkedObjectList().GetMarkCount(); }
2
←
Assuming the condition is true→
3
←
Returning the value 1, which participates in a condition later→
  OUString const & GetDescriptionOfMarkedObjects() const { return GetMarkedObjectList().GetMarkDescription(); }
  OUString const & GetDescriptionOfMarkedPoints() const { return GetMarkedObjectList().GetPointMarkDescription(); }
  OUString const & GetDescriptionOfMarkedGluePoints() const { return GetMarkedObjectList().GetGluePointMarkDescription(); }

  // Get a list of all those links which are connected to marked nodes,
  // but which are not marked themselves.
  const SdrMarkList& GetEdgesOfMarkedNodes() const { return maSdrViewSelection.GetEdgesOfMarkedNodes(); }
  const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return maSdrViewSelection.GetMarkedEdgesOfMarkedNodes(); }
  const std::vector<SdrObject*>& GetTransitiveHullOfMarkedObjects() const { return maSdrViewSelection.GetAllMarkedObjects(); }


  // mechanism to complete disable handles at the view. Handles will be hidden and deleted
  // when set, no new ones created, no interaction allowed. Handles will be recreated and shown
  // when reset. Default is false.
  void hideMarkHandles();
  void showMarkHandles();
  bool areMarkHandlesHidden() const { return mbMarkHandlesHidden; }

  bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); }
  bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const;

  SdrHdl* PickHandle(const Point& rPnt) const;

  // Pick: Supported options for nOptions are:
  // SdrSearchOptions::DEEP SdrSearchOptions::ALSOONMASTER SdrSearchOptions::TESTMARKABLE SdrSearchOptions::TESTTEXTEDIT
  // SdrSearchOptions::MARKED
  // SdrSearchOptions::WHOLEPAGE
  SdrObject* PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions, SdrObject** ppRootObj, bool* pbHitPassDirect=nullptr) const;
  SdrObject* PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions=SdrSearchOptions::NONE) const;
  bool MarkObj(const Point& rPnt, short nTol=-2, bool bToggle=false, bool bDeep=false);

  // Pick: Supported options for nOptions are SdrSearchOptions::PASS2BOUND
  bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const;

  // Selects the most upper of the marked objects (O1) and scans from there
  // towards bottom direction, selecting the first non-marked object (O2).
  // In case of success the marking of O1 is deleted, a marking is created at
  // O2 and TRUE is returned. With the parameter bPrev=sal_True the scan
  // direction is turned to the other direction.
  bool MarkNextObj(bool bPrev=false);

  // Selects the most upper of the marked objects which is hit by rPnt/nTol
  // and scans from there to bottom direction, selecting the first non-marked
  // object (O2). In case of success the marking of O1 is deleted, a marking
  // is created at O2 and sal_True is returned. With the parameter
  // bPrev=sal_True the scan direction is turned to the other direction.
  bool MarkNextObj(const Point& rPnt, short nTol, bool bPrev);

  // Mark all objects within a rectangular area
  // Just objects are marked which are inclosed completely
  void MarkObj(const tools::Rectangle& rRect, bool bUnmark);
  void MarkObj(SdrObject* pObj, SdrPageView* pPV, bool bUnmark = false, bool bDoNoSetMarkHdl = false,
               std::vector<basegfx::B2DRectangle> const & rSubSelections = std::vector<basegfx::B2DRectangle>());
  void MarkAllObj(SdrPageView* pPV=nullptr); // pPage=NULL => all displayed pages
  void UnmarkAllObj(SdrPageView const * pPV=nullptr); // pPage=NULL => all displayed pages

  // This function is time-consuming intensive, as the MarkList has to be scanned.
  bool IsObjMarked(SdrObject const * pObj) const;
  void UnMarkAll(SdrPageView const * pPV=nullptr) { UnmarkAllObj(pPV); }

  // Request/set the size of the marking handles. Declaration in Pixel.
  // The value is meant to be the edge length ( link length ).
  // Pair values are round up to impair values: 3->3, 4->5, 5->5, 6->7, 7->7, ...
  // Default value is 7, minimum value is 3 Pixels.
  sal_uInt16 GetMarkHdlSizePixel() const;
  void SetMarkHdlSizePixel(sal_uInt16 nSiz);

  virtual bool HasMarkablePoints() const;
  virtual sal_Int32 GetMarkablePointCount() const;
  virtual bool HasMarkedPoints() const;

  // There might be points which can't be marked:
  bool IsPointMarkable(const SdrHdl& rHdl) const;
  virtual bool MarkPoint(SdrHdl& rHdl, bool bUnmark=false);

  /** should only be used from outside svx for special ui elements */
  bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark);

  bool UnmarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,true); }
  bool IsPointMarked(const SdrHdl& rHdl) const { ForceUndirtyMrkPnt(); return rHdl.IsSelected(); }
  bool MarkAllPoints() { return MarkPoints(nullptr,false); }
  bool UnmarkAllPoints() { return MarkPoints(nullptr,true); }

  // Selects the first marked point (P1) which is hit by rPnt
  // and from there it searches the first non-marked point(P2).
  // In case of success the marking of
  // P1 is deleted, a mark is set at P2.
  void MarkNextPoint();

  // Search for the number of the suitable handle. In case of empty search result,
  // SAL_MAX_SIZE is returned.
  size_t GetHdlNum(SdrHdl const * pHdl) const { return maHdlList.GetHdlNum(pHdl); }
  SdrHdl* GetHdl(size_t nHdlNum)  const { return maHdlList.GetHdl(nHdlNum); }
  const SdrHdlList& GetHdlList() const { return maHdlList; }

  // Draw a selection frame for marking of points.
  // This routine will just be started in case that HasMarkablePoints() returns sal_True.
  bool BegMarkPoints(const Point& rPnt, bool bUnmark = false);
  void MovMarkPoints(const Point& rPnt);
  bool EndMarkPoints();
  void BrkMarkPoints();
  bool IsMarkPoints() const { return (nullptr != mpMarkPointsOverlay); }

  // Select that additional handles are displayed permanently.
  void SetPlusHandlesAlwaysVisible(bool bOn);
  bool IsPlusHandlesAlwaysVisible() const { return mbPlusHdlAlways; }

  bool HasMarkableGluePoints() const;
  bool HasMarkedGluePoints() const;

  // A gluepoint is clearly identified by the SdrObject
  // (to which it belongs) as well as by a sal_uInt16 nId (as each SdrObject may consist of
  // several glue points. Here at the View there is an additional
  // SdrPageView, which should be defined correctly always.
  // Alternatively a gluepoint may be characterized by a SdrHdl.
  // In this case the SdrHdl instance consists of all required information.
  // And in this case, the glue point are always is marked by enforcement
  // (Handlers are just situated at marked gluepoints )
  // Attention: With each change of the glue point status the handle list is re-calculated.
  // All previously saved SdrHdl* became invalid by this, the same with the point IDs!
  bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV) const;
  bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, bool bUnmark);
  void UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId) { MarkGluePoint(pObj,nId,true); }
  bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const;

  // Get the Hdl (handle) of a marked GluePoint. Non-marked
  // GluePoints don`t have handles
  SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const;

  // Mark all points within this rectangular (View coordinates)
  bool MarkAllGluePoints() { return MarkGluePoints(nullptr,false); }
  bool UnmarkAllGluePoints() { return MarkGluePoints(nullptr,true); }

  // Selects the first marked point (P1) which is hit by rPnt
  // and from there it searches the first non-marked point(P2).
  // In case of success the marking of
  // P1 is deleted, a mark is set at P2.
  void MarkNextGluePoint();

  // Draw a selection frame for glue point marking.
  // This routine will just be started in case that HasMarkablePoints() returns sal_True.
  // The GlueEditMode sal_True is disregarded.
  // bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut);
  bool BegMarkGluePoints(const Point& rPnt, bool bUnmark = false);
  void MovMarkGluePoints(const Point& rPnt);
  void EndMarkGluePoints();
  void BrkMarkGluePoints();
  bool IsMarkGluePoints() const { return (nullptr != mpMarkGluePointsOverlay); }

  // bRestraintPaint=sal_False causes the handles not to be drawn immediately.
  // AdjustMarkHdl is just called in case of changes; usually this causes an Invalidate
  // At the end of a redraw the handles are drawn automatically.
  // The purpose is to avoid unnecessary flickering. -> This does not yet work, that's why sal_True!
  void AdjustMarkHdl(SfxViewShell* pOtherShell = nullptr); //HMHBOOL bRestraintPaint=sal_True);

  const tools::Rectangle& GetMarkedObjRect() const; // SnapRects of Objects, without line width
  tools::Rectangle GetMarkedObjBoundRect() const;   // incl. line width, overlapping rags, ...
  const tools::Rectangle& GetMarkedPointsRect() const;     // Enclosing rectangle of all marked points
  const tools::Rectangle& GetMarkedGluePointsRect() const; // Enclosing rectangle of all marked glue points
  const tools::Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); }
  tools::Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); }

  // Will be always called, if the list of marked objects might be changed.
  // If you override this method, be sure that you call the
  // methods of the base class!
  virtual void MarkListHasChanged();

  // Entering (Editing) of a maybe marked object group. If there are several
  // object groups marked, the most upper group is selected. After that
  // all member objects of the group are directly accessible. All other
  // objects may not be processed in the meantime (until the next
  // LeaveGroup()). With markings which overlaps pages, every page is processed
  // separately. The method returns sal_True, if at least one group was entered.
  void EnterMarkedGroup();

  // Rotation center point and start point of the axis of reflection, respectively
  const Point& GetRef1() const { return maRef1; }
  void SetRef1(const Point& rPt);

  // End point of the axis of reflection
  const Point& GetRef2() const { return maRef2; }
  void SetRef2(const Point& rPt);
  /// Get access to the view shell owning this draw view, if any.
  virtual SfxViewShell* GetSfxViewShell() const;
444};


447// - Hit tolerances:
448//   It has to be declared in logical coordinates. So please translate the
449//   wanted pixel value with PixelToLogic in Logical values.
450//   Taking as example a logical value of 100:
451//   - For a horizontal hairline (Object with height 0), the generated data is +/-100, i.e.
452//     a vertical area of 200 logical units is sensitive.
453//   - For a polygon, a rectangular of the size (200,200) is generated and a
454//     touch test between Poly and this Rect is processed.
455//   - Objects which respond SdrObject::HasEdit()==TRUE ( e.g. a text frame ),
456//     are specially treated: An additional sensitive area with a width of
457//     2*Tol (200 units for this example) is created around the object.
458//     When an object is directly hit, the Edit method is called.
459//     In opposite, a hit in the surrounding sensitive area enables Dragging.


462#endif // INCLUDED_SVX_SVDMRKV_HXX

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

←

/home/maarten/src/libreoffice/core/include/vcl/bitmapex.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_BITMAPEX_HXX
21#define INCLUDED_VCL_BITMAPEX_HXX

23#include <vcl/dllapi.h>
24#include <vcl/alpha.hxx>
25#include <vcl/Scanline.hxx>
26#include <tools/color.hxx>

28#include <sal/types.h>

30namespace com::sun::star::rendering {
  class XBitmapCanvas;
32}
33namespace com::sun::star::uno { template <class interface_type> class Reference; }
34namespace basegfx { class BColorModifierStack; }

36enum class TransparentType
37{
  NONE,
  Color,
  Bitmap
41};

43class SAL_WARN_UNUSED__attribute__((warn_unused)) VCL_DLLPUBLIC__attribute__ ((visibility("default"))) BitmapEx
44{
45public:

                      BitmapEx();
  explicit            BitmapEx( const OUString& rIconName );
                      BitmapEx( const BitmapEx& rBitmapEx );
                      BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize );
                      BitmapEx( Size aSize, sal_uInt16 nBitCount );
  explicit            BitmapEx( const Bitmap& rBmp );
                      BitmapEx( const Bitmap& rBmp, const Bitmap& rMask );
                      BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask );
                      BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor );

  BitmapEx&           operator=( const BitmapEx& rBitmapEx );
  BitmapEx&           operator=( const Bitmap& rBitmap ) { return operator=(BitmapEx(rBitmap)); }
  bool                operator==( const BitmapEx& rBitmapEx ) const;
  bool                operator!=( const BitmapEx& rBitmapEx ) const { return !(*this==rBitmapEx); }
  bool                operator!() const { return !maBitmap; }
9
←
Calling 'Bitmap::operator!'→
19
←
Returning from 'Bitmap::operator!'→
20
←
Returning the value 1, which participates in a condition later→

  bool                IsEmpty() const;
  void                SetEmpty();
  void                Clear();

  void                Draw( OutputDevice* pOutDev,
                            const Point& rDestPt ) const;
  void                Draw( OutputDevice* pOutDev,
                            const Point& rDestPt, const Size& rDestSize ) const;

  bool                IsTransparent() const;
  TransparentType     GetTransparentType() const { return meTransparent; }

  Bitmap              GetBitmap( Color aTransparentReplaceColor ) const;
  /// Gives direct access to the contained bitmap.
  const Bitmap&       GetBitmap() const;
  Bitmap              GetMask() const;

  bool                IsAlpha() const;
  AlphaMask           GetAlpha() const;

  const Size&         GetSizePixel() const { return maBitmapSize; }
  void                SetSizePixel(const Size& rNewSize);

  const Size&         GetPrefSize() const { return maBitmap.GetPrefSize(); }
  void                SetPrefSize( const Size& rPrefSize ) { maBitmap.SetPrefSize( rPrefSize ); }

  const MapMode&      GetPrefMapMode() const { return maBitmap.GetPrefMapMode(); }
  void                SetPrefMapMode( const MapMode& rPrefMapMode ) { maBitmap.SetPrefMapMode( rPrefMapMode ); }

  const Color&        GetTransparentColor() const { return maTransparentColor; }

  sal_uInt16          GetBitCount() const { return maBitmap.GetBitCount(); }
  sal_uLong           GetSizeBytes() const;
  BitmapChecksum      GetChecksum() const;

  /** Convert bitmap format

      @param eConversion
      The format this bitmap should be converted to.

      @return true, if the conversion was completed successfully.
   */
  bool                Convert( BmpConversion eConversion );

  /** Crop the bitmap

      @param rRectPixel
      A rectangle specifying the crop amounts on all four sides of
      the bitmap. If the upper left corner of the bitmap is assigned
      (0,0), then this method cuts out the given rectangle from the
      bitmap. Note that the rectangle is clipped to the bitmap's
      dimension, i.e. negative left,top rectangle coordinates or
      exceeding width or height is ignored.

      @return true, if cropping was performed successfully. If
      nothing had to be cropped, because e.g. the crop rectangle
      included the bitmap, false is returned, too!
   */
  bool                Crop( const tools::Rectangle& rRectPixel );

  /** Expand the bitmap by pixel padding

      @param nDX
      Number of pixel to pad at the right border of the bitmap

      @param nDY
      Number of scanlines to pad at the bottom border of the bitmap

      @param bExpandTransparent
      Whether to expand the transparency color or not.
   */
  void                Expand(
                          sal_uLong nDX, sal_uLong nDY,
                          bool bExpandTransparent = false );

  /** Copy a rectangular area from another bitmap

      @param rRectDst
      Destination rectangle in this bitmap. This is clipped to the
      bitmap dimensions.

      @param rRectSrc
      Source rectangle in pBmpSrc. This is clipped to the source
      bitmap dimensions. Note further that no scaling takes place
      during this copy operation, i.e. only the minimum of source
      and destination rectangle's width and height are used.

      @param pBmpExSrc
      The source bitmap to copy from. If this argument is NULL, or
      equal to the object this method is called on, copying takes
      place within the same bitmap.

      @return true, if the operation completed successfully. false
      is not only returned when the operation failed, but also if
      nothing had to be done, e.g. because one of the rectangles are
      empty.
   */
  bool                CopyPixel(
                          const tools::Rectangle& rRectDst,
                          const tools::Rectangle& rRectSrc,
                          const BitmapEx* pBmpExSrc );

  /** Fill the entire bitmap with the given color

      @param rFillColor
      Color value to use for filling. Set the transparency part of
      the color to fill the mask.

      @return true, if the operation was completed successfully.
   */
  bool                Erase( const Color& rFillColor );

  /** Perform the Invert operation on every pixel

      @return true, if the operation was completed successfully.
   */
  bool                Invert();

  /** Mirror the bitmap

      @param nMirrorFlags
      About which axis (horizontal, vertical, or both) to mirror

      @return true, if the operation was completed successfully.
   */
  bool                Mirror( BmpMirrorFlags nMirrorFlags );

  /** Scale the bitmap

      @param rNewSize
      The resulting size of the scaled bitmap

      @param nScaleFlag
      The algorithm to be used for scaling

      @return true, if the operation was completed successfully.
   */
  bool                Scale(
                          const Size& rNewSize,
                          BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );

  /** Scale the bitmap

      @param rScaleX
      The scale factor in x direction.

      @param rScaleY
      The scale factor in y direction.

      @param nScaleFlag
      The algorithm to be used for scaling

      @return true, if the operation was completed successfully.
   */
  bool                Scale(
                          const double& rScaleX,
                          const double& rScaleY,
                          BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );

  /** Rotate bitmap by the specified angle

      @param nAngle10
      The rotation angle in tenth of a degree. The bitmap is always rotated around its center.

      @param rFillColor
      The color to use for filling blank areas. During rotation, the
      bitmap is enlarged such that the whole rotation result fits
      in. The empty spaces around that rotated original bitmap are
      then filled with this color.

      @return true, if the operation was completed successfully.
   */
  bool                Rotate(
                          long nAngle10,
                          const Color& rFillColor );

  /** Replace all pixel having the search color with the specified color

      @param rSearchColor
      Color specifying which pixel should be replaced

      @param rReplaceColor
      Color to be placed in all changed pixel
   */
  void                Replace(
                          const Color& rSearchColor,
                          const Color& rReplaceColor );

  /** Replace all pixel having the search color with the specified color

      @param rSearchColor
      Color specifying which pixel should be replaced

      @param rReplaceColor
      Color to be placed in all changed pixel

      @param nTolerance
      Tolerance value. Specifies the maximal difference between
      rSearchColor and the individual pixel values, such that the
      corresponding pixel is still regarded a match.
   */
  void                Replace(
                          const Color& rSearchColor,
                          const Color& rReplaceColor,
                          sal_uInt8 nTolerance );

  /** Replace all pixel having one the search colors with the corresponding replace color

      @param pSearchColors
      Array of colors specifying which pixel should be replaced

      @param pReplaceColors
      Array of colors to be placed in all changed pixel

      @param nColorCount
      Size of the aforementioned color arrays

      @param pTols
      Tolerance value. Specifies the maximal difference between
      pSearchColor colors and the individual pixel values, such that
      the corresponding pixel is still regarded a match.
   */
  void                Replace(
                          const Color* pSearchColors,
                          const Color* pReplaceColors,
                          sal_uLong nColorCount );

  /** Replace all pixel having one the search colors with the corresponding replace color

      @param pSearchColors
      Array of colors specifying which pixel should be replaced

      @param rReplaceColors
      Array of colors to be placed in all changed pixel

      @param nColorCount
      Size of the aforementioned color arrays

      @param pTols
      Tolerance value. Specifies the maximal difference between
      pSearchColor colors and the individual pixel values, such that
      the corresponding pixel is still regarded a match.

      @return true, if the operation was completed successfully.
   */
  void                Replace(
                          const Color* pSearchColors,
                          const Color* pReplaceColors,
                          sal_uLong nColorCount,
                          sal_uInt8 const * pTols );

  /** Replace transparency with given color.
   */
  void                ReplaceTransparency( const Color& rColor );

  /** Get contours in image */
  tools::Polygon      GetContour( bool bContourEdgeDetect, const tools::Rectangle* pWorkRect );

  /** Change various global color characteristics

      @param nLuminancePercent
      Percent of luminance change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nContrastPercent
      Percent of contrast change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelRPercent
      Percent of red channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelGPercent
      Percent of green channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelBPercent
      Percent of blue channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param fGamma
      Exponent of the gamma function applied to the bitmap. The
      value 1.0 results in no change, the valid range is
      (0.0,10.0]. Values outside this range are regarded as 1.0.

      @param bInvert
      If true, invert the channel values with the logical 'not' operator

      @param msoBrightness
      Use the same formula for brightness as used by MSOffice.

      @return true, if the operation was completed successfully.
   */
  bool                Adjust(
                          short nLuminancePercent,
                          short nContrastPercent,
                          short nChannelRPercent,
                          short nChannelGPercent,
                          short nChannelBPercent,
                          double fGamma = 1.0,
                          bool bInvert = false,
                          bool msoBrightness = false );

  /** Get transparency at given position

      @param nX
      integer X-Position in Bitmap

      @param nY
      integer Y-Position in Bitmap

      @return transparency value in the range of [0 .. 255] where
              0 is not transparent, 255 is fully transparent
   */
  sal_uInt8           GetTransparency(
                          sal_Int32 nX,
                          sal_Int32 nY) const;

  /** Get pixel color (including alpha) at given position

      @param nX
      integer X-Position in Bitmap

      @param nY
      integer Y-Position in Bitmap
   */
  ::Color             GetPixelColor(
                          sal_Int32 nX,
                          sal_Int32 nY) const;

  /** Create transformed Bitmap

      @param fWidth
      The target width in pixels

      @param fHeight
      The target height in pixels

      @param rTransformation
      The back transformation for each pixel in (0 .. fWidth),(0 .. fHeight) to
      local pixel coordinates
  */
  [[nodiscard]]
  BitmapEx            TransformBitmapEx(
                          double fWidth,
                          double fHeight,
                          const basegfx::B2DHomMatrix& rTransformation) const;

  /** Create transformed Bitmap

      @param rTransformation
      The transformation from unit coordinates to the unit range

      @param rVisibleRange
      The relative visible range in unit coordinates, relative to (0,0,1,1) which
      defines the whole target area

      @param fMaximumArea
      A limitation for the maximum size of pixels to use for the result

      The target size of the result bitmap is defined by transforming the given
      rTargetRange with the given rTransformation; the area of the result is
      linearly scaled to not exceed the given fMaximumArea

      @return The transformed bitmap
  */
  [[nodiscard]]
  BitmapEx            getTransformed(
                          const basegfx::B2DHomMatrix& rTransformation,
                          const basegfx::B2DRange& rVisibleRange,
                          double fMaximumArea) const;

  /** Create ColorStack-modified version of this BitmapEx

      @param rBColorModifierStack
      A ColrModifierStack which defines how each pixel has to be modified
  */
  [[nodiscard]]
  BitmapEx            ModifyBitmapEx( const basegfx::BColorModifierStack& rBColorModifierStack) const;

  [[nodiscard]]
  static BitmapEx     AutoScaleBitmap( BitmapEx const & aBitmap, const long aStandardSize );

  /// populate from a canvas implementation
  bool                Create(
                          const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas,
                          const Size &rSize );

  void                setAlphaFrom( sal_uInt8 cIndexFrom, sal_Int8 nAlphaTo );

  void                AdjustTransparency( sal_uInt8 cTrans );

  void                CombineMaskOr(Color maskColor, sal_uInt8 nTol);

  /**
   * Retrieves the color model data we need for the XImageConsumer stuff.
   */
  void                GetColorModel(css::uno::Sequence< sal_Int32 >& rRGBPalette,
                          sal_uInt32& rnRedMask, sal_uInt32& rnGreenMask, sal_uInt32& rnBlueMask, sal_uInt32& rnAlphaMask, sal_uInt32& rnTransparencyIndex,
                          sal_uInt32& rnWidth, sal_uInt32& rnHeight, sal_uInt8& rnBitCount);

  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) std::shared_ptr<SalBitmap> const & ImplGetBitmapSalBitmap() const { return maBitmap.ImplGetSalBitmap(); }
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) std::shared_ptr<SalBitmap> const & ImplGetMaskSalBitmap() const { return maMask.ImplGetSalBitmap(); }


463private:
  friend class ImpGraphic;
  friend class OutputDevice;
  friend bool VCL_DLLPUBLIC__attribute__ ((visibility("default"))) WriteDIBBitmapEx(const BitmapEx& rSource, SvStream& rOStm);
  friend bool VCL_DLLPUBLIC__attribute__ ((visibility("default"))) ReadRawDIB(BitmapEx& rTarget, const unsigned char* pBuf,
                                  const ScanlineFormat nFormat,
                                  const int nHeight,
                                  const int nStride);

  void  loadFromIconTheme( const OUString& rIconName );

  Bitmap              maBitmap;
  Bitmap              maMask;
  Size                maBitmapSize;
  Color               maTransparentColor;
  TransparentType     meTransparent;
  bool                mbAlpha;

481};


484/** Create a blend frame as BitmapEx

  @param nAlpha
  The blend value defines how strong the frame will be blended with the
  existing content, 255 == full coverage, 0 == no frame will be drawn

  @param aColorTopLeft, aColorBottomRight
  The colors defining the frame. These colors are linearly interpolated from
  aColorTopLeft and aColorBottomRight using the width and height of the area

  @param rSize
  The size of the frame in pixels
  */
497BitmapEx VCL_DLLPUBLIC__attribute__ ((visibility("default"))) createBlendFrame(
  const Size& rSize,
  sal_uInt8 nAlpha,
  Color aColorTopLeft,
  Color aColorBottomRight);


504/** Create a blend frame as BitmapEx

  @param nAlpha
  The blend value defines how strong the frame will be blended with the
  existing content, 255 == full coverage, 0 == no frame will be drawn

  @param aColorTopLeft, aColorBottomRight, aColorTopRight, aColorBottomLeft
  The colors defining the frame.

  @param rSize
  The size of the frame in pixels
  */
516BitmapEx createBlendFrame(
  const Size& rSize,
  sal_uInt8 nAlpha,
  Color aColorTopLeft,
  Color aColorTopRight,
  Color aColorBottomRight,
  Color aColorBottomLeft);

524#endif // INCLUDED_VCL_BITMAPEX_HXX

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

←

/home/maarten/src/libreoffice/core/include/vcl/bitmap.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_BITMAP_HXX
21#define INCLUDED_VCL_BITMAP_HXX

23#include <tools/solar.h>
24#include <vcl/checksum.hxx>
25#include <vcl/dllapi.h>
26#include <vcl/mapmod.hxx>
27#include <vcl/region.hxx>
28#include <vcl/scopedbitmapaccess.hxx>
29#include <o3tl/typed_flags_set.hxx>
30#include <memory>

32class Color;

34template <typename Arg, typename Ret> class Link;

36enum class BmpMirrorFlags
37{
  NONE             = 0x00,
  Horizontal       = 0x01,
  Vertical         = 0x02,
41};

43namespace o3tl
44{
  template<> struct typed_flags<BmpMirrorFlags> : is_typed_flags<BmpMirrorFlags, 0x03> {};
46}

48enum class BmpScaleFlag
49{
50// Try to preferably use these.
  Default,
  Fast,
  BestQuality,
54// Specific algorithms, use only if you really need to (mainly used for tests)
  NearestNeighbor,
  Interpolate, // fast, integer bilinear
  Lanczos,
  BiCubic,
  BiLinear,
  Super // bilinear interpolation when supersampling and averaging when subsampling under certain scale
61};

63#define BMP_COL_TRANSColor( 252, 3, 251 )               Color( 252, 3, 251 )

65enum class BmpConversion
66{
  NNONE,
  N1BitThreshold,
  N4BitGreys,
  N4BitColors,
  N8BitGreys,
  N8BitColors,
  N24Bit,
  N32Bit,
  N8BitTrans,
  N8BitNoConversion // make 8bit without color conversion (e.g. take the red channel)
77};

79enum class BmpCombine
80{
  Or, And
82};

84class   BitmapInfoAccess;
85class   BitmapReadAccess;
86class   BitmapWriteAccess;
87class   BitmapPalette;
88class   GDIMetaFile;
89class   AlphaMask;
90class   OutputDevice;
91class   SalBitmap;

93struct BitmapSystemData
94{
  #if defined(_WIN32)
  void* pDIB; // device independent byte buffer
  #elif defined( MACOSX ) || defined( IOS )
  // Nothing needed, apparently
  #else
  void* aPixmap;
  #endif
  int mnWidth;
  int mnHeight;
104};

106class SAL_WARN_UNUSED__attribute__((warn_unused)) VCL_DLLPUBLIC__attribute__ ((visibility("default"))) Bitmap
107{
108public:

                          Bitmap();
                          Bitmap( const Bitmap& rBitmap );
                          Bitmap( const Size& rSizePixel, sal_uInt16 nBitCount, const BitmapPalette* pPal = nullptr );
  explicit                Bitmap( std::shared_ptr<SalBitmap> const & xSalBitmap );
  virtual                 ~Bitmap();

  Bitmap&                 operator=( const Bitmap& rBitmap );
  Bitmap&                 operator=( Bitmap&& rBitmap ) noexcept;
  inline bool             operator!() const;
  bool                    operator==( const Bitmap& rBitmap ) const;
  bool                    operator!=( const Bitmap& rBitmap ) const { return !operator==(rBitmap); }

  inline bool             IsEmpty() const;
  void                    SetEmpty();

  inline const MapMode&   GetPrefMapMode() const;
  inline void             SetPrefMapMode( const MapMode& rMapMode );

  inline const Size&      GetPrefSize() const;
  inline void             SetPrefSize( const Size& rSize );

  Size                    GetSizePixel() const;

  sal_uInt16              GetBitCount() const;
  inline sal_Int64        GetColorCount() const;
  inline sal_uLong        GetSizeBytes() const;
  bool                    HasGreyPalette8Bit() const;
  bool                    HasGreyPaletteAny() const;
  /** get system dependent bitmap data

      @param rData
      The system dependent BitmapSystemData structure to be filled

      @return true if the bitmap has a valid system object (e.g. not empty)
  */
  bool                    GetSystemData( BitmapSystemData& rData ) const;

  BitmapChecksum          GetChecksum() const;

  Bitmap                  CreateDisplayBitmap( OutputDevice* pDisplay ) const;

  static const BitmapPalette&
                          GetGreyPalette( int nEntries );

154public:

  /** Convert bitmap format

      @param eConversion
      The format this bitmap should be converted to.

      @return true the conversion was completed successfully.
   */
  bool                    Convert( BmpConversion eConversion );

  /** Apply a Floyd dither algorithm to the bitmap

   This method dithers the bitmap inplace, i.e. a true color
   bitmap is converted to a paletted bitmap, reducing the color
   deviation by error diffusion.

   */
  bool                    Dither();

  /** Crop the bitmap

      @param rRectPixel
      A rectangle specifying the crop amounts on all four sides of
      the bitmap. If the upper left corner of the bitmap is assigned
      (0,0), then this method cuts out the given rectangle from the
      bitmap. Note that the rectangle is clipped to the bitmap's
      dimension, i.e. negative left,top rectangle coordinates or
      exceeding width or height is ignored.

      @return true cropping was performed successfully. If
      nothing had to be cropped, because e.g. the crop rectangle
      included the bitmap, false is returned, too!
   */
  bool                    Crop( const tools::Rectangle& rRectPixel );

  /** Expand the bitmap by pixel padding

      @param nDX
      Number of pixel to pad at the right border of the bitmap

      @param nDY
      Number of scanlines to pad at the bottom border of the bitmap

      @param pInitColor
      Color to use for padded pixel

      @return true, if padding was performed successfully. false is
      not only returned when the operation failed, but also if
      nothing had to be done, e.g. because nDX and nDY were zero.
   */
  bool                    Expand(
                              sal_uLong nDX, sal_uLong nDY,
                              const Color* pInitColor = nullptr );

  /** Copy a rectangular area from another bitmap

      @param rRectDst
      Destination rectangle in this bitmap. This is clipped to the
      bitmap dimensions.

      @param rRectSrc
      Source rectangle in pBmpSrc. This is clipped to the source
      bitmap dimensions. Note further that no scaling takes place
      during this copy operation, i.e. only the minimum of source
      and destination rectangle's width and height are used.

      @param pBmpSrc
      The source bitmap to copy from. If this argument is NULL, or
      equal to the object this method is called on, copying takes
      place within the same bitmap.

      @return true, if the operation completed successfully. false
      is not only returned when the operation failed, but also if
      nothing had to be done, e.g. because one of the rectangles are
      empty.
   */
  bool                    CopyPixel(
                              const tools::Rectangle& rRectDst,
                              const tools::Rectangle& rRectSrc,
                              const Bitmap* pBmpSrc = nullptr );

  bool                    CopyPixel_AlphaOptimized(
                              const tools::Rectangle& rRectDst,
                              const tools::Rectangle& rRectSrc,
                              const Bitmap* pBmpSrc );

  /** Perform boolean operations with another bitmap

      @param rMask
      The mask bitmap in the selected combine operation

      @param eCombine
      The combine operation to perform on the bitmap

      @return true, if the operation was completed successfully.
   */
  bool                    CombineSimple(
                              const Bitmap& rMask,
                              BmpCombine eCombine );

  /** Alpha-blend the given bitmap against a specified uniform
        background color.

      @attention This method might convert paletted bitmaps to
      truecolor, to be able to represent every necessary color. Note
      that during alpha blending, lots of colors not originally
      included in the bitmap can be generated.

      @param rAlpha
      Alpha mask to blend with

      @param rBackgroundColor
      Background color to use for every pixel during alpha blending

      @return true, if blending was successful, false otherwise
   */
  bool                    Blend(
                              const AlphaMask& rAlpha,
                              const Color& rBackgroundColor );

  /** Fill the entire bitmap with the given color

      @param rFillColor
      Color value to use for filling

      @return true, if the operation was completed successfully.
   */
  bool                    Erase( const Color& rFillColor );

  /** Perform the Invert operation on every pixel

      @return true, if the operation was completed successfully.
   */
  bool                    Invert();

  /** Mirror the bitmap

      @param nMirrorFlags
      About which axis (horizontal, vertical, or both) to mirror

      @return true, if the operation was completed successfully.
   */
  bool                    Mirror( BmpMirrorFlags nMirrorFlags );

  /** Scale the bitmap

      @param rNewSize
      The resulting size of the scaled bitmap

      @param nScaleFlag
      The algorithm to be used for scaling

      @return true, if the operation was completed successfully.
   */
  bool                    Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );

  /** Scale the bitmap

      @param rScaleX
      The scale factor in x direction.

      @param rScaleY
      The scale factor in y direction.

      @param nScaleFlag
      Method of scaling - it is recommended that either BmpScaleFlag::Default or BmpScaleFlag::BestQuality be used.

      @return true, if the operation was completed successfully.
   */
  bool                    Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );

  /**
    Returns true if bitmap scaling is considered to be fast.

    Currently this returns true if OpenGL is used for scaling, otherwise false (CPU scaling is slower).

    @since 4.5
  */
  static bool HasFastScale();

  // Adapt the BitCount of rNew to BitCount of total, including grey or color palette
  // Can be used to create alpha/mask bitmaps after their processing in 24bit
  void AdaptBitCount(Bitmap& rNew) const;

  /** Rotate bitmap by the specified angle

      @param nAngle10
      The rotation angle in tenth of a degree. The bitmap is always rotated around its center.

      @param rFillColor
      The color to use for filling blank areas. During rotation, the
      bitmap is enlarged such that the whole rotation result fits
      in. The empty spaces around that rotated original bitmap are
      then filled with this color.

      @return true, if the operation was completed successfully.
   */
  bool                    Rotate( long nAngle10, const Color& rFillColor );

  /** Create on-off mask from bitmap

      This method creates a bitmask from the bitmap, where every
      pixel that equals rTransColor is set transparent, the rest
      opaque.

      @param rTransColor
      Color value where the bitmask should be transparent

      @param nTol
      Tolerance value. Specifies the maximal difference between
      rTransColor and the individual pixel values, such that the
      corresponding pixel is still regarded as transparent.

      @return the resulting bitmask.
   */
  Bitmap                  CreateMask( const Color& rTransColor, sal_uInt8 nTol = 0 ) const;

  /** Create region of similar colors in a given rectangle

      @param rColor
      All pixel which have this color are included in the calculated region

      @param rRect
      The rectangle within which matching pixel are looked for. This
      rectangle is always clipped to the bitmap dimensions.

      @return the generated region.
   */
  vcl::Region                  CreateRegion( const Color& rColor, const tools::Rectangle& rRect ) const;

  /** Replace all pixel where the given mask is on with the specified color

      @param rMask
      Mask specifying which pixel should be replaced

      @param rReplaceColor
      Color to be placed in all changed pixel

      @return true, if the operation was completed successfully.
   */
  bool                    Replace( const Bitmap& rMask, const Color& rReplaceColor );

  /** Merge bitmap with given background color according to specified alpha mask

      @param rAlpha
      Alpha mask specifying the amount of background color to merge in

      @param rMergeColor
      Background color to be used for merging

      @return true, if the operation was completed successfully.
   */
  bool                    Replace( const AlphaMask& rAlpha, const Color& rMergeColor );

  /** Replace all pixel having the search color with the specified color

      @param rSearchColor
      Color specifying which pixel should be replaced

      @param rReplaceColor
      Color to be placed in all changed pixel

      @param nTol
      Tolerance value. Specifies the maximal difference between
      rSearchColor and the individual pixel values, such that the
      corresponding pixel is still regarded a match.

      @return true, if the operation was completed successfully.
   */
  bool                    Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uInt8 nTol = 0 );

  /** Replace all pixel having one the search colors with the corresponding replace color

      @param pSearchColors
      Array of colors specifying which pixel should be replaced

      @param rReplaceColors
      Array of colors to be placed in all changed pixel

      @param nColorCount
      Size of the aforementioned color arrays

      @param pTols
      Tolerance value. Specifies the maximal difference between
      pSearchColor colors and the individual pixel values, such that
      the corresponding pixel is still regarded a match.

      @return true, if the operation was completed successfully.
   */
  bool                    Replace(
                              const Color* pSearchColors,
                              const Color* rReplaceColors,
                              sal_uLong nColorCount,
                              sal_uInt8 const * pTols );

  /** Convert the bitmap to a meta file

      This works by putting continuous areas of the same color into
      polygons painted in this color, by tracing the area's bounding
      line.

      @param rMtf
      The resulting meta file

      @param cReduce
      If non-null, minimal size of bound rects for individual polygons. Smaller ones are ignored.

      @param pProgress
      A callback for showing the progress of the vectorization
   */
  void                    Vectorize(
                              GDIMetaFile& rMtf,
                              sal_uInt8 cReduce,
                              const Link<long,void>* pProgress );

  /** Change various global color characteristics

      @param nLuminancePercent
      Percent of luminance change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nContrastPercent
      Percent of contrast change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelRPercent
      Percent of red channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelGPercent
      Percent of green channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param nChannelBPercent
      Percent of blue channel change, valid range [-100,100]. Values outside this range are clipped to the valid range.

      @param fGamma
      Exponent of the gamma function applied to the bitmap. The
      value 1.0 results in no change, the valid range is
      (0.0,10.0]. Values outside this range are regarded as 1.0.

      @param bInvert
      If true, invert the channel values with the logical 'not' operator

      @param msoBrightness
      Use the same formula for brightness as used by MSOffice.

      @return true, if the operation was completed successfully.
   */
  bool                    Adjust(
                              short nLuminancePercent,
                              short nContrastPercent = 0,
                              short nChannelRPercent = 0,
                              short nChannelGPercent = 0,
                              short nChannelBPercent = 0,
                              double fGamma = 1.0,
                              bool bInvert = false,
                              bool msoBrightness = false );

510public:
  /** ReassignWithSize and recalculate bitmap.

    ReassignWithSizes the bitmap, and recalculates the bitmap size based on the new bitmap.

    @param rBitmap Bitmap to reassign and use for size calculation
   */
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) void     ReassignWithSize(const Bitmap& rBitmap);

  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) void     ImplMakeUnique();
  const std::shared_ptr<SalBitmap>& ImplGetSalBitmap() const { return mxSalBmp; }
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) void     ImplSetSalBitmap( const std::shared_ptr<SalBitmap>& xImpBmp );

  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool     ImplMakeGreyscales( sal_uInt16 nGreyscales );

525public:

  BitmapInfoAccess*       AcquireInfoAccess();
  BitmapReadAccess*       AcquireReadAccess();
  BitmapWriteAccess*      AcquireWriteAccess();
  static void             ReleaseAccess( BitmapInfoAccess* pAccess );

  typedef vcl::ScopedBitmapAccess<BitmapReadAccess, Bitmap, &Bitmap::AcquireReadAccess> ScopedReadAccess;
  typedef vcl::ScopedBitmapAccess<BitmapInfoAccess, Bitmap, &Bitmap::AcquireInfoAccess> ScopedInfoAccess;

535private:
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool ImplConvertUp(sal_uInt16 nBitCount, Color const* pExtColor = nullptr);
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool ImplConvertDown(sal_uInt16 nBitCount, Color const* pExtColor = nullptr);

539private:
  std::shared_ptr<SalBitmap> mxSalBmp;
  MapMode maPrefMapMode;
  Size maPrefSize;

544};

546inline bool Bitmap::operator!() const
547{
  return( mxSalBmp == nullptr );
10
←
Calling 'operator==<SalBitmap>'→
17
←
Returning from 'operator==<SalBitmap>'→
18
←
Returning the value 1, which participates in a condition later→
549}

551inline bool Bitmap::IsEmpty() const
552{
  return( mxSalBmp == nullptr );
554}

556inline const MapMode& Bitmap::GetPrefMapMode() const
557{
  return maPrefMapMode;
559}

561inline void Bitmap::SetPrefMapMode( const MapMode& rMapMode )
562{
  maPrefMapMode = rMapMode;
564}

566inline const Size& Bitmap::GetPrefSize() const
567{
  return maPrefSize;
569}

571inline void Bitmap::SetPrefSize( const Size& rSize )
572{
  maPrefSize = rSize;
574}

576inline sal_Int64 Bitmap::GetColorCount() const
577{
  return sal_Int64(1) << sal_Int64(GetBitCount());
579}

581inline sal_uLong Bitmap::GetSizeBytes() const
582{
  const Size aSizePix( GetSizePixel() );
  return( ( static_cast<sal_uLong>(aSizePix.Width()) * aSizePix.Height() * GetBitCount() ) >> 3 );
585}

587#endif // INCLUDED_VCL_BITMAP_HXX

589/* 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)...)
{ }

    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; }
11
←
Calling '__shared_ptr::operator bool'→
15
←
Returning from '__shared_ptr::operator bool'→
16
←
Returning the value 1, which participates in a condition later→

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},
	     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>(),
		       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(),
     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)...);
 __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; }
12
←
Assuming field '_M_ptr' is equal to null→
13
←
'?' condition is true→
14
←
Returning zero, which participates in a condition later→

    /// 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)...)
{ _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