/home/maarten/src/libreoffice/core/include/o3tl/cow

Bug Summary

File:	home/maarten/src/libreoffice/core/include/o3tl/cow_wrapper.hxx
Warning:	line 291, column 17 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name poly.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 TOOLS_DLLIMPLEMENTATION -D SYSTEM_ZLIB -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/tools/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/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx

/home/maarten/src/libreoffice/core/tools/source/generic/poly.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 <osl/endian.h>
21#include <osl/diagnose.h>
22#include <sal/log.hxx>
23#include <tools/bigint.hxx>
24#include <tools/debug.hxx>
25#include <tools/helpers.hxx>
26#include <tools/stream.hxx>
27#include <tools/vcompat.hxx>
28#include <tools/gen.hxx>
29#include <poly.h>
30#include <o3tl/safeint.hxx>
31#include <tools/line.hxx>
32#include <tools/poly.hxx>
33#include <basegfx/polygon/b2dpolygon.hxx>
34#include <basegfx/point/b2dpoint.hxx>
35#include <basegfx/vector/b2dvector.hxx>
36#include <basegfx/polygon/b2dpolygontools.hxx>
37#include <basegfx/curve/b2dcubicbezier.hxx>

39#include <memory>
40#include <vector>
41#include <iterator>
42#include <algorithm>
43#include <cstring>
44#include <limits.h>
45#include <cmath>

47#define EDGE_LEFT1       1
48#define EDGE_TOP2        2
49#define EDGE_RIGHT4      4
50#define EDGE_BOTTOM8     8
51#define EDGE_HORZ(4 | 1)       (EDGE_RIGHT4 | EDGE_LEFT1)
52#define EDGE_VERT(2 | 8)       (EDGE_TOP2 | EDGE_BOTTOM8)
53#define SMALL_DVALUE0.0000001    0.0000001
54#define FSQRT21.4142135623730950488016887242097          1.4142135623730950488016887242097

56static double ImplGetParameter( const Point& rCenter, const Point& rPt, double fWR, double fHR )
57{
  const long nDX = rPt.X() - rCenter.X();
  double fAngle = atan2( -rPt.Y() + rCenter.Y(), ( ( nDX == 0 ) ? 0.000000001 : nDX ) );

  return atan2(fWR*sin(fAngle), fHR*cos(fAngle));
62}

64ImplPolygon::ImplPolygon( sal_uInt16 nInitSize  )
65{
  ImplInitSize(nInitSize, false);
67}

69ImplPolygon::ImplPolygon( const ImplPolygon& rImpPoly )
70{
  if ( rImpPoly.mnPoints )
  {
      mxPointAry.reset(new Point[rImpPoly.mnPoints]);
      memcpy(mxPointAry.get(), rImpPoly.mxPointAry.get(), rImpPoly.mnPoints * sizeof(Point));

      if( rImpPoly.mxFlagAry )
      {
          mxFlagAry.reset(new PolyFlags[rImpPoly.mnPoints]);
          memcpy(mxFlagAry.get(), rImpPoly.mxFlagAry.get(), rImpPoly.mnPoints);
      }
  }

  mnPoints   = rImpPoly.mnPoints;
84}

86ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, const Point* pInitAry, const PolyFlags* pInitFlags )
87{
  if ( nInitSize )
  {
      mxPointAry.reset(new Point[nInitSize]);
      memcpy(mxPointAry.get(), pInitAry, nInitSize * sizeof(Point));

      if( pInitFlags )
      {
          mxFlagAry.reset(new PolyFlags[nInitSize]);
          memcpy(mxFlagAry.get(), pInitFlags, nInitSize);
      }
  }

  mnPoints   = nInitSize;
101}

103ImplPolygon::ImplPolygon( const tools::Rectangle& rRect )
104{
  if ( !rRect.IsEmpty() )
  {
       ImplInitSize(5);
       mxPointAry[0] = rRect.TopLeft();
       mxPointAry[1] = rRect.TopRight();
       mxPointAry[2] = rRect.BottomRight();
       mxPointAry[3] = rRect.BottomLeft();
       mxPointAry[4] = rRect.TopLeft();
  }
  else
      mnPoints = 0;
116}

118ImplPolygon::ImplPolygon( const tools::Rectangle& rRect, sal_uInt32 nHorzRound, sal_uInt32 nVertRound )
119{
  if ( !rRect.IsEmpty() )
  {
      tools::Rectangle aRect( rRect );
      aRect.Justify();            // SJ: i9140

      nHorzRound = std::min( nHorzRound, static_cast<sal_uInt32>(labs( aRect.GetWidth() >> 1 )) );
      nVertRound = std::min( nVertRound, static_cast<sal_uInt32>(labs( aRect.GetHeight() >> 1 )) );

      if( !nHorzRound && !nVertRound )
      {
          ImplInitSize(5);
          mxPointAry[0] = aRect.TopLeft();
          mxPointAry[1] = aRect.TopRight();
          mxPointAry[2] = aRect.BottomRight();
          mxPointAry[3] = aRect.BottomLeft();
          mxPointAry[4] = aRect.TopLeft();
      }
      else
      {
          const Point     aTL( aRect.Left() + nHorzRound, aRect.Top() + nVertRound );
          const Point     aTR( aRect.Right() - nHorzRound, aRect.Top() + nVertRound );
          const Point     aBR( aRect.Right() - nHorzRound, aRect.Bottom() - nVertRound );
          const Point     aBL( aRect.Left() + nHorzRound, aRect.Bottom() - nVertRound );
          std::unique_ptr<tools::Polygon> pEllipsePoly( new tools::Polygon( Point(), nHorzRound, nVertRound ) );
          sal_uInt16 i, nEnd, nSize4 = pEllipsePoly->GetSize() >> 2;

          ImplInitSize((pEllipsePoly->GetSize() + 1));

          const Point* pSrcAry = pEllipsePoly->GetConstPointAry();
          Point* pDstAry = mxPointAry.get();

          for( i = 0, nEnd = nSize4; i < nEnd; i++ )
              pDstAry[ i ] = pSrcAry[ i ] + aTR;

          for( nEnd = nEnd + nSize4; i < nEnd; i++ )
              pDstAry[ i ] = pSrcAry[ i ] + aTL;

          for( nEnd = nEnd + nSize4; i < nEnd; i++ )
              pDstAry[ i ] = pSrcAry[ i ] + aBL;

          for( nEnd = nEnd + nSize4; i < nEnd; i++ )
              pDstAry[ i ] = pSrcAry[ i ] + aBR;

          pDstAry[ nEnd ] = pDstAry[ 0 ];
      }
  }
  else
      mnPoints = 0;
168}

170ImplPolygon::ImplPolygon( const Point& rCenter, long nRadX, long nRadY )
171{
  if( nRadX && nRadY )
  {
      sal_uInt16 nPoints;
      // Compute default (depends on size)
      long nRadXY;
      const bool bOverflow = o3tl::checked_multiply(nRadX, nRadY, nRadXY);
      if (!bOverflow)
      {
          nPoints = static_cast<sal_uInt16>(MinMax(
              ( F_PI3.14159265358979323846 * ( 1.5 * ( nRadX + nRadY ) -
                         sqrt( static_cast<double>(labs(nRadXY)) ) ) ),
              32, 256 ));
      }
      else
      {
         nPoints = 256;
      }

      if( ( nRadX > 32 ) && ( nRadY > 32 ) && ( nRadX + nRadY ) < 8192 )
          nPoints >>= 1;

      // Ceil number of points until divisible by four
      nPoints = (nPoints + 3) & ~3;
      ImplInitSize(nPoints);

      sal_uInt16 i;
      sal_uInt16 nPoints2 = nPoints >> 1;
      sal_uInt16 nPoints4 = nPoints >> 2;
      double nAngle;
      double nAngleStep = F_PI21.57079632679489661923 / ( nPoints4 - 1 );

      for( i=0, nAngle = 0.0; i < nPoints4; i++, nAngle += nAngleStep )
      {
          long nX = FRound( nRadX * cos( nAngle ) );
          long nY = FRound( -nRadY * sin( nAngle ) );

          Point* pPt = &(mxPointAry[i]);
          pPt->setX(  nX + rCenter.X() );
          pPt->setY(  nY + rCenter.Y() );
          pPt = &(mxPointAry[nPoints2-i-1]);
          pPt->setX( -nX + rCenter.X() );
          pPt->setY(  nY + rCenter.Y() );
          pPt = &(mxPointAry[i+nPoints2]);
          pPt->setX( -nX + rCenter.X() );
          pPt->setY( -nY + rCenter.Y() );
          pPt = &(mxPointAry[nPoints-i-1]);
          pPt->setX(  nX + rCenter.X() );
          pPt->setY( -nY + rCenter.Y() );
      }
  }
  else
      mnPoints = 0;
224}

226ImplPolygon::ImplPolygon( const tools::Rectangle& rBound, const Point& rStart, const Point& rEnd,
  PolyStyle eStyle )
228{
  const long  nWidth = rBound.GetWidth();
  const long  nHeight = rBound.GetHeight();

  if( ( nWidth > 1 ) && ( nHeight > 1 ) )
  {
      const Point aCenter( rBound.Center() );
      const long  nRadX = aCenter.X() - rBound.Left();
      const long  nRadY = aCenter.Y() - rBound.Top();
      sal_uInt16  nPoints;

      long nRadXY;
      const bool bOverflow = o3tl::checked_multiply(nRadX, nRadY, nRadXY);
      if (!bOverflow)
      {
          nPoints = static_cast<sal_uInt16>(MinMax(
              ( F_PI3.14159265358979323846 * ( 1.5 * ( nRadX + nRadY ) -
                         sqrt( static_cast<double>(labs(nRadXY)) ) ) ),
              32, 256 ));
      }
      else
      {
          nPoints = 256;
      }


      if( ( nRadX > 32 ) && ( nRadY > 32 ) && ( nRadX + nRadY ) < 8192 )
          nPoints >>= 1;

      // compute threshold
      const double    fRadX = nRadX;
      const double    fRadY = nRadY;
      const double    fCenterX = aCenter.X();
      const double    fCenterY = aCenter.Y();
      double          fStart = ImplGetParameter( aCenter, rStart, fRadX, fRadY );
      double          fEnd = ImplGetParameter( aCenter, rEnd, fRadX, fRadY );
      double          fDiff = fEnd - fStart;
      double          fStep;
      sal_uInt16      nStart;
      sal_uInt16      nEnd;

      if( fDiff < 0. )
          fDiff += F_2PI(2.0*3.14159265358979323846);

      // Proportionally shrink number of points( fDiff / (2PI) );
      nPoints = std::max( static_cast<sal_uInt16>( ( fDiff * 0.1591549 ) * nPoints ), sal_uInt16(16) );
      fStep = fDiff / ( nPoints - 1 );

      if( PolyStyle::Pie == eStyle )
      {
          const Point aCenter2( FRound( fCenterX ), FRound( fCenterY ) );

          nStart = 1;
          nEnd = nPoints + 1;
          ImplInitSize((nPoints + 2));
          mxPointAry[0] = aCenter2;
          mxPointAry[nEnd] = aCenter2;
      }
      else
      {
          ImplInitSize( ( PolyStyle::Chord == eStyle ) ? ( nPoints + 1 ) : nPoints );
          nStart = 0;
          nEnd = nPoints;
      }

      for(; nStart < nEnd; nStart++, fStart += fStep )
      {
          Point& rPt = mxPointAry[nStart];

          rPt.setX( FRound( fCenterX + fRadX * cos( fStart ) ) );
          rPt.setY( FRound( fCenterY - fRadY * sin( fStart ) ) );
      }

      if( PolyStyle::Chord == eStyle )
          mxPointAry[nPoints] = mxPointAry[0];
  }
  else
      mnPoints = 0;
306}

308ImplPolygon::ImplPolygon( const Point& rBezPt1, const Point& rCtrlPt1,
  const Point& rBezPt2, const Point& rCtrlPt2, sal_uInt16 nPoints )
310{
  nPoints = ( 0 == nPoints ) ? 25 : ( ( nPoints < 2 ) ? 2 : nPoints );

  const double    fInc = 1.0 / ( nPoints - 1 );
  double          fK_1 = 0.0, fK1_1 = 1.0;
  double          fK_2, fK_3, fK1_2, fK1_3;
  const double    fX0 = rBezPt1.X();
  const double    fY0 = rBezPt1.Y();
  const double    fX1 = 3.0 * rCtrlPt1.X();
  const double    fY1 = 3.0 * rCtrlPt1.Y();
  const double    fX2 = 3.0 * rCtrlPt2.X();
  const double    fY2 = 3.0 * rCtrlPt2.Y();
  const double    fX3 = rBezPt2.X();
  const double    fY3 = rBezPt2.Y();

  ImplInitSize(nPoints);

  for( sal_uInt16 i = 0; i < nPoints; i++, fK_1 += fInc, fK1_1 -= fInc )
  {
      Point& rPt = mxPointAry[i];

      fK_2 = fK_1;
      fK_2 *= fK_1;
      fK_3 = fK_2;
      fK_3 *= fK_1;
      fK1_2 = fK1_1;
      fK1_2 *= fK1_1;
      fK1_3 = fK1_2;
      fK1_3 *= fK1_1;
      double fK12 = fK_1 * fK1_2;
      double fK21 = fK_2 * fK1_1;

      rPt.setX( FRound( fK1_3 * fX0 + fK12 * fX1 + fK21 * fX2 + fK_3 * fX3 ) );
      rPt.setY( FRound( fK1_3 * fY0 + fK12 * fY1 + fK21 * fY2 + fK_3 * fY3 ) );
  }
345}

347// constructor to convert from basegfx::B2DPolygon
348// #i76891# Needed to change from adding all control points (even for unused
349// edges) and creating a fixed-size Polygon in the first run to creating the
350// minimal Polygon. This requires a temporary Point- and Flag-Array for curves
351// and a memcopy at ImplPolygon creation, but contains no zero-controlpoints
352// for straight edges.
353ImplPolygon::ImplPolygon(const basegfx::B2DPolygon& rPolygon)
  : mnPoints(0)
355{
  const bool bCurve(rPolygon.areControlPointsUsed());
  const bool bClosed(rPolygon.isClosed());
  sal_uInt32 nB2DLocalCount(rPolygon.count());

  if(bCurve)
  {
      // #127979# Reduce source point count hard to the limit of the tools Polygon
      if(nB2DLocalCount > ((0x0000ffff / 3) - 1))
      {
          OSL_FAIL("Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "365" ": "), "%s", "Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)"
); } } while (false);
          nB2DLocalCount = ((0x0000ffff / 3) - 1);
      }

      // calculate target point count
      const sal_uInt32 nLoopCount(bClosed ? nB2DLocalCount : (nB2DLocalCount ? nB2DLocalCount - 1 : 0 ));

      if(nLoopCount)
      {
          // calculate maximum array size and allocate; prepare insert index
          const sal_uInt32 nMaxTargetCount((nLoopCount * 3) + 1);
          ImplInitSize(static_cast< sal_uInt16 >(nMaxTargetCount), true);

          // prepare insert index and current point
          sal_uInt32 nArrayInsert(0);
          basegfx::B2DCubicBezier aBezier;
          aBezier.setStartPoint(rPolygon.getB2DPoint(0));

          for(sal_uInt32 a(0); a < nLoopCount; a++)
          {
              // add current point (always) and remember StartPointIndex for evtl. later corrections
              const Point aStartPoint(FRound(aBezier.getStartPoint().getX()), FRound(aBezier.getStartPoint().getY()));
              const sal_uInt32 nStartPointIndex(nArrayInsert);
              mxPointAry[nStartPointIndex] = aStartPoint;
              mxFlagAry[nStartPointIndex] = PolyFlags::Normal;
              nArrayInsert++;

              // prepare next segment
              const sal_uInt32 nNextIndex((a + 1) % nB2DLocalCount);
              aBezier.setEndPoint(rPolygon.getB2DPoint(nNextIndex));
              aBezier.setControlPointA(rPolygon.getNextControlPoint(a));
              aBezier.setControlPointB(rPolygon.getPrevControlPoint(nNextIndex));

              if(aBezier.isBezier())
              {
                  // if one is used, add always two control points due to the old schema
                  mxPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointA().getX()), FRound(aBezier.getControlPointA().getY()));
                  mxFlagAry[nArrayInsert] = PolyFlags::Control;
                  nArrayInsert++;

                  mxPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointB().getX()), FRound(aBezier.getControlPointB().getY()));
                  mxFlagAry[nArrayInsert] = PolyFlags::Control;
                  nArrayInsert++;
              }

              // test continuity with previous control point to set flag value
              if(aBezier.getControlPointA() != aBezier.getStartPoint() && (bClosed || a))
              {
                  const basegfx::B2VectorContinuity eCont(rPolygon.getContinuityInPoint(a));

                  if(basegfx::B2VectorContinuity::C1 == eCont)
                  {
                      mxFlagAry[nStartPointIndex] = PolyFlags::Smooth;
                  }
                  else if(basegfx::B2VectorContinuity::C2 == eCont)
                  {
                      mxFlagAry[nStartPointIndex] = PolyFlags::Symmetric;
                  }
              }

              // prepare next polygon step
              aBezier.setStartPoint(aBezier.getEndPoint());
          }

          if(bClosed)
          {
              // add first point again as closing point due to old definition
              mxPointAry[nArrayInsert] = mxPointAry[0];
              mxFlagAry[nArrayInsert] = PolyFlags::Normal;
              nArrayInsert++;
          }
          else
          {
              // add last point as closing point
              const basegfx::B2DPoint aClosingPoint(rPolygon.getB2DPoint(nB2DLocalCount - 1));
              const Point aEnd(FRound(aClosingPoint.getX()), FRound(aClosingPoint.getY()));
              mxPointAry[nArrayInsert] = aEnd;
              mxFlagAry[nArrayInsert] = PolyFlags::Normal;
              nArrayInsert++;
          }

          DBG_ASSERT(nArrayInsert <= nMaxTargetCount, "Polygon::Polygon from basegfx::B2DPolygon: wrong max point count estimation (!)")do { if (true && (!(nArrayInsert <= nMaxTargetCount
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "446" ": "), "%s", "Polygon::Polygon from basegfx::B2DPolygon: wrong max point count estimation (!)"
); } } while (false);

          if(nArrayInsert != nMaxTargetCount)
          {
              ImplSetSize(static_cast< sal_uInt16 >(nArrayInsert));
          }
      }
  }
  else
  {
      // #127979# Reduce source point count hard to the limit of the tools Polygon
      if(nB2DLocalCount > (0x0000ffff - 1))
      {
          OSL_FAIL("Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "459" ": "), "%s", "Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)"
); } } while (false);
          nB2DLocalCount = (0x0000ffff - 1);
      }

      if(nB2DLocalCount)
      {
          // point list creation
          const sal_uInt32 nTargetCount(nB2DLocalCount + (bClosed ? 1 : 0));
          ImplInitSize(static_cast< sal_uInt16 >(nTargetCount));
          sal_uInt16 nIndex(0);

          for(sal_uInt32 a(0); a < nB2DLocalCount; a++)
          {
              basegfx::B2DPoint aB2DPoint(rPolygon.getB2DPoint(a));
              Point aPoint(FRound(aB2DPoint.getX()), FRound(aB2DPoint.getY()));
              mxPointAry[nIndex++] = aPoint;
          }

          if(bClosed)
          {
              // add first point as closing point
              mxPointAry[nIndex] = mxPointAry[0];
          }
      }
  }
484}

486bool ImplPolygon::operator==( const ImplPolygon& rCandidate) const
487{
  return mnPoints == rCandidate.mnPoints &&
         mxFlagAry.get() == rCandidate.mxFlagAry.get() &&
         mxPointAry.get() == rCandidate.mxPointAry.get();
491}

493void ImplPolygon::ImplInitSize(sal_uInt16 nInitSize, bool bFlags)
494{
  if (nInitSize)
  {
      mxPointAry.reset(new Point[nInitSize]);
  }

  if (bFlags)
  {
      mxFlagAry.reset(new PolyFlags[nInitSize]);
      memset(mxFlagAry.get(), 0, nInitSize);
  }

  mnPoints = nInitSize;
507}

509void ImplPolygon::ImplSetSize( sal_uInt16 nNewSize, bool bResize )
510{
  if( mnPoints == nNewSize )
      return;

  std::unique_ptr<Point[]> xNewAry;

  if (nNewSize)
  {
      const std::size_t nNewSz(static_cast<std::size_t>(nNewSize)*sizeof(Point));
      xNewAry.reset(new Point[nNewSize]);

      if ( bResize )
      {
          // Copy the old points
          if ( mnPoints < nNewSize )
          {
              // New points are already implicitly initialized to zero
              const std::size_t nOldSz(mnPoints * sizeof(Point));
              if (mxPointAry)
                  memcpy(xNewAry.get(), mxPointAry.get(), nOldSz);
          }
          else
          {
              if (mxPointAry)
                  memcpy(xNewAry.get(), mxPointAry.get(), nNewSz);
          }
      }
  }

  mxPointAry = std::move(xNewAry);

  // take FlagArray into account, if applicable
  if( mxFlagAry )
  {
      std::unique_ptr<PolyFlags[]> xNewFlagAry;

      if( nNewSize )
      {
          xNewFlagAry.reset(new PolyFlags[nNewSize]);

          if( bResize )
          {
              // copy the old flags
              if ( mnPoints < nNewSize )
              {
                  // initialize new flags to zero
                  memset(xNewFlagAry.get() + mnPoints, 0, nNewSize-mnPoints);
                  memcpy(xNewFlagAry.get(), mxFlagAry.get(), mnPoints);
              }
              else
                  memcpy(xNewFlagAry.get(), mxFlagAry.get(), nNewSize);
          }
      }

      mxFlagAry = std::move(xNewFlagAry);
  }

  mnPoints   = nNewSize;
568}

570bool ImplPolygon::ImplSplit( sal_uInt16 nPos, sal_uInt16 nSpace, ImplPolygon const * pInitPoly )
571{
  //Can't fit this in :-(, throw ?
  if (mnPoints + nSpace > USHRT_MAX(32767 *2 +1))
  {
      SAL_WARN("tools", "Polygon needs " << mnPoints + nSpace << " points, but only " << USHRT_MAX << " possible")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "tools")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Polygon needs " << mnPoints + nSpace <<
 " points, but only " << (32767 *2 +1) << " possible"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "575" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Polygon needs " << mnPoints + nSpace
 << " points, but only " << (32767 *2 +1) <<
 " possible"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Polygon needs " << mnPoints
 + nSpace << " points, but only " << (32767 *2 +1
) << " possible"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "575" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Polygon needs " << mnPoints + nSpace <<
 " points, but only " << (32767 *2 +1) << " possible"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "575" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Polygon needs " << mnPoints + nSpace
 << " points, but only " << (32767 *2 +1) <<
 " possible"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Polygon needs " << mnPoints
 + nSpace << " points, but only " << (32767 *2 +1
) << " possible"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "575" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return false;
  }

  const sal_uInt16    nNewSize = mnPoints + nSpace;
  const std::size_t   nSpaceSize = static_cast<std::size_t>(nSpace) * sizeof(Point);

  if( nPos >= mnPoints )
  {
      // Append at the back
      nPos = mnPoints;
      ImplSetSize( nNewSize );

      if( pInitPoly )
      {
          memcpy(mxPointAry.get() + nPos, pInitPoly->mxPointAry.get(), nSpaceSize);

          if (pInitPoly->mxFlagAry)
              memcpy(mxFlagAry.get() + nPos, pInitPoly->mxFlagAry.get(), nSpace);
      }
  }
  else
  {
      const sal_uInt16    nSecPos = nPos + nSpace;
      const sal_uInt16    nRest = mnPoints - nPos;

      std::unique_ptr<Point[]> xNewAry(new Point[nNewSize]);
      memcpy(xNewAry.get(), mxPointAry.get(), nPos * sizeof(Point));

      if( pInitPoly )
          memcpy(xNewAry.get() + nPos, pInitPoly->mxPointAry.get(), nSpaceSize);

      memcpy(xNewAry.get() + nSecPos, mxPointAry.get() + nPos, nRest * sizeof(Point));
      mxPointAry = std::move(xNewAry);

      // consider FlagArray
      if (mxFlagAry)
      {
          std::unique_ptr<PolyFlags[]> xNewFlagAry(new PolyFlags[nNewSize]);

          memcpy(xNewFlagAry.get(), mxFlagAry.get(), nPos);

          if (pInitPoly && pInitPoly->mxFlagAry)
              memcpy(xNewFlagAry.get() + nPos, pInitPoly->mxFlagAry.get(), nSpace);
          else
              memset(xNewFlagAry.get() + nPos, 0, nSpace);

          memcpy(xNewFlagAry.get() + nSecPos, mxFlagAry.get() + nPos, nRest);
          mxFlagAry = std::move(xNewFlagAry);
      }

      mnPoints   = nNewSize;
  }

  return true;
630}

632void ImplPolygon::ImplCreateFlagArray()
633{
  if (!mxFlagAry)
  {
      mxFlagAry.reset(new PolyFlags[mnPoints]);
      memset(mxFlagAry.get(), 0, mnPoints);
  }
639}

641namespace {

643class ImplPointFilter
644{
645public:
  virtual void LastPoint() = 0;
  virtual void Input( const Point& rPoint ) = 0;

649protected:
  ~ImplPointFilter() {}
651};

653class ImplPolygonPointFilter : public ImplPointFilter
654{
  ImplPolygon maPoly;
  sal_uInt16  mnSize;
657public:
  explicit ImplPolygonPointFilter(sal_uInt16 nDestSize)
      : maPoly(nDestSize)
      , mnSize(0)
  {
  }

  virtual ~ImplPolygonPointFilter()
  {
  }

  virtual void    LastPoint() override;
  virtual void    Input( const Point& rPoint ) override;

  ImplPolygon&    get() { return maPoly; }
672};

674}

676void ImplPolygonPointFilter::Input( const Point& rPoint )
677{
  if ( !mnSize || (rPoint != maPoly.mxPointAry[mnSize-1]) )
  {
      mnSize++;
      if ( mnSize > maPoly.mnPoints )
          maPoly.ImplSetSize( mnSize );
      maPoly.mxPointAry[mnSize-1] = rPoint;
  }
685}

687void ImplPolygonPointFilter::LastPoint()
688{
  if ( mnSize < maPoly.mnPoints )
      maPoly.ImplSetSize( mnSize );
691};

693namespace {

695class ImplEdgePointFilter : public ImplPointFilter
696{
  Point               maFirstPoint;
  Point               maLastPoint;
  ImplPointFilter&    mrNextFilter;
  const long          mnLow;
  const long          mnHigh;
  const int           mnEdge;
  int                 mnLastOutside;
  bool                mbFirst;

706public:
                      ImplEdgePointFilter( int nEdge, long nLow, long nHigh,
                                           ImplPointFilter& rNextFilter ) :
                          mrNextFilter( rNextFilter ),
                          mnLow( nLow ),
                          mnHigh( nHigh ),
                          mnEdge( nEdge ),
                          mnLastOutside( 0 ),
                          mbFirst( true )
                      {
                      }

  virtual             ~ImplEdgePointFilter() {}

  Point               EdgeSection( const Point& rPoint, int nEdge ) const;
  int                 VisibleSide( const Point& rPoint ) const;
  bool                IsPolygon() const
                          { return maFirstPoint == maLastPoint; }

  virtual void        Input( const Point& rPoint ) override;
  virtual void        LastPoint() override;
727};

729}

731inline int ImplEdgePointFilter::VisibleSide( const Point& rPoint ) const
732{
  if ( mnEdge & EDGE_HORZ(4 | 1) )
  {
      return rPoint.X() < mnLow ? EDGE_LEFT1 :
                                   rPoint.X() > mnHigh ? EDGE_RIGHT4 : 0;
  }
  else
  {
      return rPoint.Y() < mnLow ? EDGE_TOP2 :
                                   rPoint.Y() > mnHigh ? EDGE_BOTTOM8 : 0;
  }
743}

745Point ImplEdgePointFilter::EdgeSection( const Point& rPoint, int nEdge ) const
746{
  long lx = maLastPoint.X();
  long ly = maLastPoint.Y();
  long md = rPoint.X() - lx;
  long mn = rPoint.Y() - ly;
  long nNewX;
  long nNewY;

  if ( nEdge & EDGE_VERT(2 | 8) )
  {
      nNewY = (nEdge == EDGE_TOP2) ? mnLow : mnHigh;
      long dy = nNewY - ly;
      if ( !md )
          nNewX = lx;
      else if ( (LONG_MAX9223372036854775807L / std::abs(md)) >= std::abs(dy) )
          nNewX = (dy * md) / mn + lx;
      else
      {
          BigInt ady = dy;
          ady *= md;
          if( ady.IsNeg() )
              if( mn < 0 )
                  ady += mn/2;
              else
                  ady -= (mn-1)/2;
          else
              if( mn < 0 )
                  ady -= (mn+1)/2;
              else
                  ady += mn/2;
          ady /= mn;
          nNewX = static_cast<long>(ady) + lx;
      }
  }
  else
  {
      nNewX = (nEdge == EDGE_LEFT1) ? mnLow : mnHigh;
      long dx = nNewX - lx;
      if ( !mn )
          nNewY = ly;
      else if ( (LONG_MAX9223372036854775807L / std::abs(mn)) >= std::abs(dx) )
          nNewY = (dx * mn) / md + ly;
      else
      {
          BigInt adx = dx;
          adx *= mn;
          if( adx.IsNeg() )
              if( md < 0 )
                  adx += md/2;
              else
                  adx -= (md-1)/2;
          else
              if( md < 0 )
                  adx -= (md+1)/2;
              else
                  adx += md/2;
          adx /= md;
          nNewY = static_cast<long>(adx) + ly;
      }
  }

  return Point( nNewX, nNewY );
808}

810void ImplEdgePointFilter::Input( const Point& rPoint )
811{
  int nOutside = VisibleSide( rPoint );

  if ( mbFirst )
  {
      maFirstPoint = rPoint;
      mbFirst      = false;
      if ( !nOutside )
          mrNextFilter.Input( rPoint );
  }
  else if ( rPoint == maLastPoint )
      return;
  else if ( !nOutside )
  {
      if ( mnLastOutside )
          mrNextFilter.Input( EdgeSection( rPoint, mnLastOutside ) );
      mrNextFilter.Input( rPoint );
  }
  else if ( !mnLastOutside )
      mrNextFilter.Input( EdgeSection( rPoint, nOutside ) );
  else if ( nOutside != mnLastOutside )
  {
      mrNextFilter.Input( EdgeSection( rPoint, mnLastOutside ) );
      mrNextFilter.Input( EdgeSection( rPoint, nOutside ) );
  }

  maLastPoint    = rPoint;
  mnLastOutside  = nOutside;
839}

841void ImplEdgePointFilter::LastPoint()
842{
  if ( !mbFirst )
  {
      int nOutside = VisibleSide( maFirstPoint );

      if ( nOutside != mnLastOutside )
          Input( maFirstPoint );
      mrNextFilter.LastPoint();
  }
851}

853namespace tools
854{

856tools::Polygon Polygon::SubdivideBezier( const tools::Polygon& rPoly )
857{
  tools::Polygon aPoly;

  // #100127# Use adaptive subdivide instead of fixed 25 segments
  rPoly.AdaptiveSubdivide( aPoly );

  return aPoly;
864}

866Polygon::Polygon() : mpImplPolygon(ImplPolygon())
867{
868}

870Polygon::Polygon( sal_uInt16 nSize ) : mpImplPolygon(ImplPolygon(nSize))
871{
872}

874Polygon::Polygon( sal_uInt16 nPoints, const Point* pPtAry, const PolyFlags* pFlagAry ) : mpImplPolygon(ImplPolygon(nPoints, pPtAry, pFlagAry))
875{
876}

878Polygon::Polygon( const tools::Polygon& rPoly ) : mpImplPolygon(rPoly.mpImplPolygon)
879{
880}

882Polygon::Polygon( tools::Polygon&& rPoly) noexcept
  : mpImplPolygon(std::move(rPoly.mpImplPolygon))
884{
885}

887Polygon::Polygon( const tools::Rectangle& rRect ) : mpImplPolygon(ImplPolygon(rRect))
888{
889}

891Polygon::Polygon( const tools::Rectangle& rRect, sal_uInt32 nHorzRound, sal_uInt32 nVertRound )
  : mpImplPolygon(ImplPolygon(rRect, nHorzRound, nVertRound))
893{
894}

896Polygon::Polygon( const Point& rCenter, long nRadX, long nRadY )
  : mpImplPolygon(ImplPolygon(rCenter, nRadX, nRadY))
898{
899}

901Polygon::Polygon( const tools::Rectangle& rBound, const Point& rStart, const Point& rEnd,
                PolyStyle eStyle ) : mpImplPolygon(ImplPolygon(rBound, rStart, rEnd, eStyle))
903{
904}

906Polygon::Polygon( const Point& rBezPt1, const Point& rCtrlPt1,
                const Point& rBezPt2, const Point& rCtrlPt2,
                sal_uInt16 nPoints ) : mpImplPolygon(ImplPolygon(rBezPt1, rCtrlPt1, rBezPt2, rCtrlPt2, nPoints))
909{
910}

912Polygon::~Polygon()
913{
914}
17
←
Calling '~cow_wrapper'→
22
←
Returning from '~cow_wrapper'→

916Point * Polygon::GetPointAry()
917{
  return mpImplPolygon->mxPointAry.get();
919}

921const Point* Polygon::GetConstPointAry() const
922{
  return mpImplPolygon->mxPointAry.get();
924}

926const PolyFlags* Polygon::GetConstFlagAry() const
927{
  return mpImplPolygon->mxFlagAry.get();
929}

931void Polygon::SetPoint( const Point& rPt, sal_uInt16 nPos )
932{
  DBG_ASSERT( nPos < mpImplPolygon->mnPoints,do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "934" ": "), "%s", "Polygon::SetPoint(): nPos >= nPoints"
); } } while (false)
              "Polygon::SetPoint(): nPos >= nPoints" )do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "934" ": "), "%s", "Polygon::SetPoint(): nPos >= nPoints"
); } } while (false);

  mpImplPolygon->mxPointAry[nPos] = rPt;
937}

939void Polygon::SetFlags( sal_uInt16 nPos, PolyFlags eFlags )
940{
  DBG_ASSERT( nPos < mpImplPolygon->mnPoints,do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "942" ": "), "%s", "Polygon::SetFlags(): nPos >= nPoints"
); } } while (false)
              "Polygon::SetFlags(): nPos >= nPoints" )do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "942" ": "), "%s", "Polygon::SetFlags(): nPos >= nPoints"
); } } while (false);

  // we do only want to create the flag array if there
  // is at least one flag different to PolyFlags::Normal
  if ( eFlags != PolyFlags::Normal )
  {
      mpImplPolygon->ImplCreateFlagArray();
      mpImplPolygon->mxFlagAry[ nPos ] = eFlags;
  }
951}

953const Point& Polygon::GetPoint( sal_uInt16 nPos ) const
954{
  DBG_ASSERT( nPos < mpImplPolygon->mnPoints,do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "956" ": "), "%s", "Polygon::GetPoint(): nPos >= nPoints"
); } } while (false)
              "Polygon::GetPoint(): nPos >= nPoints" )do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "956" ": "), "%s", "Polygon::GetPoint(): nPos >= nPoints"
); } } while (false);

  return mpImplPolygon->mxPointAry[nPos];
959}

961PolyFlags Polygon::GetFlags( sal_uInt16 nPos ) const
962{
  DBG_ASSERT( nPos < mpImplPolygon->mnPoints,do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "964" ": "), "%s", "Polygon::GetFlags(): nPos >= nPoints"
); } } while (false)
              "Polygon::GetFlags(): nPos >= nPoints" )do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "964" ": "), "%s", "Polygon::GetFlags(): nPos >= nPoints"
); } } while (false);
  return mpImplPolygon->mxFlagAry
         ? mpImplPolygon->mxFlagAry[ nPos ]
         : PolyFlags::Normal;
968}

970bool Polygon::HasFlags() const
971{
  return bool(mpImplPolygon->mxFlagAry);
973}

975bool Polygon::IsRect() const
976{
  bool bIsRect = false;
  if (!mpImplPolygon->mxFlagAry)
  {
      if ( ( ( mpImplPolygon->mnPoints == 5 ) && ( mpImplPolygon->mxPointAry[ 0 ] == mpImplPolygon->mxPointAry[ 4 ] ) ) ||
           ( mpImplPolygon->mnPoints == 4 ) )
      {
          if ( ( mpImplPolygon->mxPointAry[ 0 ].X() == mpImplPolygon->mxPointAry[ 3 ].X() ) &&
               ( mpImplPolygon->mxPointAry[ 0 ].Y() == mpImplPolygon->mxPointAry[ 1 ].Y() ) &&
               ( mpImplPolygon->mxPointAry[ 1 ].X() == mpImplPolygon->mxPointAry[ 2 ].X() ) &&
               ( mpImplPolygon->mxPointAry[ 2 ].Y() == mpImplPolygon->mxPointAry[ 3 ].Y() ) )
              bIsRect = true;
      }
  }
  return bIsRect;
991}

993void Polygon::SetSize( sal_uInt16 nNewSize )
994{
  if( nNewSize != mpImplPolygon->mnPoints )
  {
      mpImplPolygon->ImplSetSize( nNewSize );
  }
999}

1001sal_uInt16 Polygon::GetSize() const
1002{
  return mpImplPolygon->mnPoints;
1004}

1006void Polygon::Clear()
1007{
  mpImplPolygon = ImplType(ImplPolygon());
1009}

1011double Polygon::CalcDistance( sal_uInt16 nP1, sal_uInt16 nP2 ) const
1012{
  DBG_ASSERT( nP1 < mpImplPolygon->mnPoints,do { if (true && (!(nP1 < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1014" ": "), "%s", "Polygon::CalcDistance(): nPos1 >= nPoints"
); } } while (false)
              "Polygon::CalcDistance(): nPos1 >= nPoints" )do { if (true && (!(nP1 < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1014" ": "), "%s", "Polygon::CalcDistance(): nPos1 >= nPoints"
); } } while (false);
  DBG_ASSERT( nP2 < mpImplPolygon->mnPoints,do { if (true && (!(nP2 < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1016" ": "), "%s", "Polygon::CalcDistance(): nPos2 >= nPoints"
); } } while (false)
              "Polygon::CalcDistance(): nPos2 >= nPoints" )do { if (true && (!(nP2 < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1016" ": "), "%s", "Polygon::CalcDistance(): nPos2 >= nPoints"
); } } while (false);

  const Point& rP1 = mpImplPolygon->mxPointAry[ nP1 ];
  const Point& rP2 = mpImplPolygon->mxPointAry[ nP2 ];
  const double fDx = rP2.X() - rP1.X();
  const double fDy = rP2.Y() - rP1.Y();

  return sqrt( fDx * fDx + fDy * fDy );
1024}

1026void Polygon::Optimize( PolyOptimizeFlags nOptimizeFlags )
1027{
  DBG_ASSERT( !mpImplPolygon->mxFlagAry, "Optimizing could fail with beziers!" )do { if (true && (!(!mpImplPolygon->mxFlagAry))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1028" ": "), "%s", "Optimizing could fail with beziers!"
); } } while (false);
1
Taking true branch→
2
←
Loop condition is false.  Exiting loop→

  sal_uInt16 nSize = mpImplPolygon->mnPoints;

  if( !(bool(nOptimizeFlags) && nSize) )
3
←
Assuming 'nOptimizeFlags' is not equal to 0→
4
←
Assuming the condition is false→
5
←
Taking false branch→
      return;

  if( nOptimizeFlags & PolyOptimizeFlags::EDGES )
6
←
Taking false branch→
  {
      const tools::Rectangle aBound( GetBoundRect() );
      const double    fArea = ( aBound.GetWidth() + aBound.GetHeight() ) * 0.5;
      const sal_uInt16 nPercent = 50;

      Optimize( PolyOptimizeFlags::NO_SAME );
      ImplReduceEdges( *this, fArea, nPercent );
  }
  else if( nOptimizeFlags & PolyOptimizeFlags::NO_SAME )
7
←
Taking true branch→
  {
      tools::Polygon aNewPoly;
      const Point& rFirst = mpImplPolygon->mxPointAry[ 0 ];

      while( nSize7.1
'nSize' is not equal to 0
1
'nSize' is not equal to 0
 && ( mpImplPolygon->mxPointAry[ nSize - 1 ] == rFirst ) )
8
←
Loop condition is false. Execution continues on line 1052→
          nSize--;

      if( nSize > 1 )
9
←
Assuming 'nSize' is > 1→
10
←
Taking true branch→
      {
          sal_uInt16 nLast = 0, nNewCount = 1;

          aNewPoly.SetSize( nSize );
          aNewPoly[ 0 ] = rFirst;

          for( sal_uInt16 i = 1; i10.1
'i' is < 'nSize'
1
'i' is < 'nSize'
 < nSize; i++ )
11
←
Loop condition is true.  Entering loop body→
13
←
Assuming 'i' is >= 'nSize'→
14
←
Loop condition is false. Execution continues on line 1068→
          {
              if( mpImplPolygon->mxPointAry[ i ] != mpImplPolygon->mxPointAry[ nLast ])
12
←
Taking true branch→
              {
                  nLast = i;
                  aNewPoly[ nNewCount++ ] = mpImplPolygon->mxPointAry[ i ];
              }
          }

          if( nNewCount14.1
'nNewCount' is not equal to 1
1
'nNewCount' is not equal to 1
 == 1 )
15
←
Taking false branch→
              aNewPoly.Clear();
          else
              aNewPoly.SetSize( nNewCount );
      }

      *this = aNewPoly;
  }
16
←
Calling '~Polygon'→
23
←
Returning from '~Polygon'→

  nSize = mpImplPolygon->mnPoints;
24
←
Calling 'cow_wrapper::operator->'→

  if( nSize > 1 )
  {
      if( ( nOptimizeFlags & PolyOptimizeFlags::CLOSE ) &&
          ( mpImplPolygon->mxPointAry[ 0 ] != mpImplPolygon->mxPointAry[ nSize - 1 ] ) )
      {
          SetSize( mpImplPolygon->mnPoints + 1 );
          mpImplPolygon->mxPointAry[ mpImplPolygon->mnPoints - 1 ] = mpImplPolygon->mxPointAry[ 0 ];
      }
  }
1088}


1091/** Recursively subdivide cubic bezier curve via deCasteljau.

 @param rPointIter
 Output iterator, where the subdivided polylines are written to.

 @param d
 Squared difference of curve to a straight line

 @param P*
 Exactly four points, interpreted as support and control points of
 a cubic bezier curve. Must be in device coordinates, since stop
 criterion is based on the following assumption: the device has a
 finite resolution, it is thus sufficient to stop subdivision if the
 curve does not deviate more than one pixel from a straight line.

1106*/
1107static void ImplAdaptiveSubdivide( ::std::back_insert_iterator< ::std::vector< Point > >& rPointIter,
                                 const double old_d2,
                                 int recursionDepth,
                                 const double d2,
                                 const double P1x, const double P1y,
                                 const double P2x, const double P2y,
                                 const double P3x, const double P3y,
                                 const double P4x, const double P4y )
1115{
  // Hard limit on recursion depth, empiric number.
  enum {maxRecursionDepth=128};

  // Perform bezier flatness test (lecture notes from R. Schaback,
  // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)

  // ||P(t) - L(t)|| <= max     ||b_j - b_0 - j/n(b_n - b_0)||
  //                    0<=j<=n

  // What is calculated here is an upper bound to the distance from
  // a line through b_0 and b_3 (P1 and P4 in our notation) and the
  // curve. We can drop 0 and n from the running indices, since the
  // argument of max becomes zero for those cases.
  const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
  const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
  const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
  const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
  const double distance2( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
                                      fJ2x*fJ2x + fJ2y*fJ2y) );

  // stop if error measure does not improve anymore. This is a
  // safety guard against floating point inaccuracies.
  // stop at recursion level 128. This is a safety guard against
  // floating point inaccuracies.
  // stop if distance from line is guaranteed to be bounded by d
  if( old_d2 > d2 &&
      recursionDepth < maxRecursionDepth &&
      distance2 >= d2 )
  {
      // deCasteljau bezier arc, split at t=0.5
      // Foley/vanDam, p. 508
      const double L1x( P1x ),             L1y( P1y );
      const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
      const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
      const double L3x( (L2x + Hx)*0.5 ),  L3y( (L2y + Hy)*0.5 );
      const double R4x( P4x ),             R4y( P4y );
      const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
      const double R2x( (Hx + R3x)*0.5 ),  R2y( (Hy + R3y)*0.5 );
      const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
      const double L4x( R1x ),             L4y( R1y );

      // subdivide further
      ++recursionDepth;
      ImplAdaptiveSubdivide(rPointIter, distance2, recursionDepth, d2, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y);
      ImplAdaptiveSubdivide(rPointIter, distance2, recursionDepth, d2, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y);
  }
  else
  {
      // requested resolution reached.
      // Add end points to output iterator.
      // order is preserved, since this is so to say depth first traversal.
      *rPointIter++ = Point( FRound(P1x), FRound(P1y) );
  }
1169}

1171void Polygon::AdaptiveSubdivide( Polygon& rResult, const double d ) const
1172{
  if (!mpImplPolygon->mxFlagAry)
  {
      rResult = *this;
  }
  else
  {
      sal_uInt16 i;
      sal_uInt16 nPts( GetSize() );
      ::std::vector< Point > aPoints;
      aPoints.reserve( nPts );
      ::std::back_insert_iterator< ::std::vector< Point > > aPointIter( aPoints );

      for(i=0; i<nPts;)
      {
          if( ( i + 3 ) < nPts )
          {
              PolyFlags P1( mpImplPolygon->mxFlagAry[ i ] );
              PolyFlags P4( mpImplPolygon->mxFlagAry[ i + 3 ] );

              if( ( PolyFlags::Normal == P1 || PolyFlags::Smooth == P1 || PolyFlags::Symmetric == P1 ) &&
                  ( PolyFlags::Control == mpImplPolygon->mxFlagAry[ i + 1 ] ) &&
                  ( PolyFlags::Control == mpImplPolygon->mxFlagAry[ i + 2 ] ) &&
                  ( PolyFlags::Normal == P4 || PolyFlags::Smooth == P4 || PolyFlags::Symmetric == P4 ) )
              {
                  ImplAdaptiveSubdivide( aPointIter, d*d+1.0, 0, d*d,
                                         mpImplPolygon->mxPointAry[ i ].X(),   mpImplPolygon->mxPointAry[ i ].Y(),
                                         mpImplPolygon->mxPointAry[ i+1 ].X(), mpImplPolygon->mxPointAry[ i+1 ].Y(),
                                         mpImplPolygon->mxPointAry[ i+2 ].X(), mpImplPolygon->mxPointAry[ i+2 ].Y(),
                                         mpImplPolygon->mxPointAry[ i+3 ].X(), mpImplPolygon->mxPointAry[ i+3 ].Y() );
                  i += 3;
                  continue;
              }
          }

          *aPointIter++ = mpImplPolygon->mxPointAry[ i++ ];

          if (aPoints.size() >= SAL_MAX_UINT16((sal_uInt16) 0xFFFF))
          {
              OSL_ENSURE(aPoints.size() < SAL_MAX_UINT16,do { if (true && (!(aPoints.size() < ((sal_uInt16)
 0xFFFF)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1213" ": "), "%s", "Polygon::AdaptiveSubdivision created polygon too many points;"
 " using original polygon instead"); } } while (false)
                  "Polygon::AdaptiveSubdivision created polygon too many points;"do { if (true && (!(aPoints.size() < ((sal_uInt16)
 0xFFFF)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1213" ": "), "%s", "Polygon::AdaptiveSubdivision created polygon too many points;"
 " using original polygon instead"); } } while (false)
                  " using original polygon instead")do { if (true && (!(aPoints.size() < ((sal_uInt16)
 0xFFFF)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1213" ": "), "%s", "Polygon::AdaptiveSubdivision created polygon too many points;"
 " using original polygon instead"); } } while (false);

              // The resulting polygon can not hold all the points
              // that we have created so far.  Stop the subdivision
              // and return a copy of the unmodified polygon.
              rResult = *this;
              return;
          }
      }

      // fill result polygon
      rResult = tools::Polygon( static_cast<sal_uInt16>(aPoints.size()) ); // ensure sufficient size for copy
      ::std::copy(aPoints.begin(), aPoints.end(), rResult.mpImplPolygon->mxPointAry.get());
  }
1227}

1229namespace {

1231class Vector2D
1232{
1233private:
  double              mfX;
  double              mfY;
1236public:
  explicit     Vector2D( const Point& rPoint ) : mfX( rPoint.X() ), mfY( rPoint.Y() ) {};
  double       GetLength() const { return hypot( mfX, mfY ); }
  Vector2D&    operator-=( const Vector2D& rVec ) { mfX -= rVec.mfX; mfY -= rVec.mfY; return *this; }
  double       Scalar( const Vector2D& rVec ) const { return mfX * rVec.mfX + mfY * rVec.mfY ; }
  Vector2D&    Normalize();
  bool         IsPositive( Vector2D const & rVec ) const { return ( mfX * rVec.mfY - mfY * rVec.mfX ) >= 0.0; }
  bool         IsNegative( Vector2D const & rVec ) const { return !IsPositive( rVec ); }
1244};

1246}

1248Vector2D& Vector2D::Normalize()
1249{
  double fLen = Scalar( *this );

  if( ( fLen != 0.0 ) && ( fLen != 1.0 ) )
  {
      fLen = sqrt( fLen );
      if( fLen != 0.0 )
      {
          mfX /= fLen;
          mfY /= fLen;
      }
  }

  return *this;
1263}

1265void Polygon::ImplReduceEdges( tools::Polygon& rPoly, const double& rArea, sal_uInt16 nPercent )
1266{
  const double    fBound = 2000.0 * ( 100 - nPercent ) * 0.01;
  sal_uInt16      nNumNoChange = 0,
                  nNumRuns = 0;

  while( nNumNoChange < 2 )
  {
      sal_uInt16  nPntCnt = rPoly.GetSize(), nNewPos = 0;
      tools::Polygon aNewPoly( nPntCnt );
      bool bChangeInThisRun = false;

      for( sal_uInt16 n = 0; n < nPntCnt; n++ )
      {
          bool bDeletePoint = false;

          if( ( n + nNumRuns ) % 2 )
          {
              sal_uInt16      nIndPrev = !n ? nPntCnt - 1 : n - 1;
              sal_uInt16      nIndPrevPrev = !nIndPrev ? nPntCnt - 1 : nIndPrev - 1;
              sal_uInt16      nIndNext = ( n == nPntCnt-1 ) ? 0 : n + 1;
              sal_uInt16      nIndNextNext = ( nIndNext == nPntCnt - 1 ) ? 0 : nIndNext + 1;
              Vector2D    aVec1( rPoly[ nIndPrev ] ); aVec1 -= Vector2D(rPoly[ nIndPrevPrev ]);
              Vector2D    aVec2( rPoly[ n ] ); aVec2 -= Vector2D(rPoly[ nIndPrev ]);
              Vector2D    aVec3( rPoly[ nIndNext ] ); aVec3 -= Vector2D(rPoly[ n ]);
              Vector2D    aVec4( rPoly[ nIndNextNext ] ); aVec4 -= Vector2D(rPoly[ nIndNext ]);
              double      fDist1 = aVec1.GetLength(), fDist2 = aVec2.GetLength();
              double      fDist3 = aVec3.GetLength(), fDist4 = aVec4.GetLength();
              double      fTurnB = aVec2.Normalize().Scalar( aVec3.Normalize() );

              if( fabs( fTurnB ) < ( 1.0 + SMALL_DVALUE0.0000001 ) && fabs( fTurnB ) > ( 1.0 - SMALL_DVALUE0.0000001 ) )
                  bDeletePoint = true;
              else
              {
                  Vector2D    aVecB( rPoly[ nIndNext ] );
                  aVecB -= Vector2D(rPoly[ nIndPrev ] );
                  double      fDistB = aVecB.GetLength();
                  double      fLenWithB = fDist2 + fDist3;
                  double      fLenFact = ( fDistB != 0.0 ) ? fLenWithB / fDistB : 1.0;
                  double      fTurnPrev = aVec1.Normalize().Scalar( aVec2 );
                  double      fTurnNext = aVec3.Scalar( aVec4.Normalize() );
                  double      fGradPrev, fGradB, fGradNext;

                  if( fabs( fTurnPrev ) < ( 1.0 + SMALL_DVALUE0.0000001 ) && fabs( fTurnPrev ) > ( 1.0 - SMALL_DVALUE0.0000001 ) )
                      fGradPrev = 0.0;
                  else
                      fGradPrev = basegfx::rad2deg(acos(fTurnPrev)) * (aVec1.IsNegative(aVec2) ? -1 : 1);

                  fGradB = basegfx::rad2deg(acos(fTurnB)) * (aVec2.IsNegative(aVec3) ? -1 : 1);

                  if( fabs( fTurnNext ) < ( 1.0 + SMALL_DVALUE0.0000001 ) && fabs( fTurnNext ) > ( 1.0 - SMALL_DVALUE0.0000001 ) )
                      fGradNext = 0.0;
                  else
                      fGradNext = basegfx::rad2deg(acos(fTurnNext)) * (aVec3.IsNegative(aVec4) ? -1 : 1);

                  if( ( fGradPrev > 0.0 && fGradB < 0.0 && fGradNext > 0.0 ) ||
                      ( fGradPrev < 0.0 && fGradB > 0.0 && fGradNext < 0.0 ) )
                  {
                      if( ( fLenFact < ( FSQRT21.4142135623730950488016887242097 + SMALL_DVALUE0.0000001 ) ) &&
                          ( ( ( fDist1 + fDist4 ) / ( fDist2 + fDist3 ) ) * 2000.0 ) > fBound )
                      {
                          bDeletePoint = true;
                      }
                  }
                  else
                  {
                      double fRelLen = 1.0 - sqrt( fDistB / rArea );

                      if( fRelLen < 0.0 )
                          fRelLen = 0.0;
                      else if( fRelLen > 1.0 )
                          fRelLen = 1.0;

                      if( ( std::round( ( fLenFact - 1.0 ) * 1000000.0 ) < fBound ) &&
                          ( fabs( fGradB ) <= ( fRelLen * fBound * 0.01 ) ) )
                      {
                          bDeletePoint = true;
                      }
                  }
              }
          }

          if( !bDeletePoint )
              aNewPoly[ nNewPos++ ] = rPoly[ n ];
          else
              bChangeInThisRun = true;
      }

      if( bChangeInThisRun && nNewPos )
      {
          aNewPoly.SetSize( nNewPos );
          rPoly = aNewPoly;
          nNumNoChange = 0;
      }
      else
          nNumNoChange++;

      nNumRuns++;
  }
1364}

1366void Polygon::Move( long nHorzMove, long nVertMove )
1367{
  // This check is required for DrawEngine
  if ( !nHorzMove && !nVertMove )
      return;

  // Move points
  sal_uInt16 nCount = mpImplPolygon->mnPoints;
  for ( sal_uInt16 i = 0; i < nCount; i++ )
  {
      Point& rPt = mpImplPolygon->mxPointAry[i];
      rPt.AdjustX(nHorzMove );
      rPt.AdjustY(nVertMove );
  }
1380}

1382void Polygon::Translate(const Point& rTrans)
1383{
  for ( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
      mpImplPolygon->mxPointAry[ i ] += rTrans;
1386}

1388void Polygon::Scale( double fScaleX, double fScaleY )
1389{
  for ( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
  {
      Point& rPnt = mpImplPolygon->mxPointAry[i];
      rPnt.setX( static_cast<long>( fScaleX * rPnt.X() ) );
      rPnt.setY( static_cast<long>( fScaleY * rPnt.Y() ) );
  }
1396}

1398void Polygon::Rotate( const Point& rCenter, sal_uInt16 nAngle10 )
1399{
  nAngle10 %= 3600;

  if( nAngle10 )
  {
      const double fAngle = F_PI1800(3.14159265358979323846/1800.0) * nAngle10;
      Rotate( rCenter, sin( fAngle ), cos( fAngle ) );
  }
1407}

1409void Polygon::Rotate( const Point& rCenter, double fSin, double fCos )
1410{
  long nCenterX = rCenter.X();
  long nCenterY = rCenter.Y();

  for( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
  {
      Point& rPt = mpImplPolygon->mxPointAry[ i ];

      const long nX = rPt.X() - nCenterX;
      const long nY = rPt.Y() - nCenterY;
      rPt.setX( FRound( fCos * nX + fSin * nY ) + nCenterX );
      rPt.setY( - FRound( fSin * nX - fCos * nY ) + nCenterY );
  }
1423}

1425void Polygon::Clip( const tools::Rectangle& rRect )
1426{
  // #105251# Justify rect before edge filtering
  tools::Rectangle               aJustifiedRect( rRect );
  aJustifiedRect.Justify();

  sal_uInt16              nSourceSize = mpImplPolygon->mnPoints;
  ImplPolygonPointFilter  aPolygon( nSourceSize );
  ImplEdgePointFilter     aHorzFilter( EDGE_HORZ(4 | 1), aJustifiedRect.Left(), aJustifiedRect.Right(),
                                       aPolygon );
  ImplEdgePointFilter     aVertFilter( EDGE_VERT(2 | 8), aJustifiedRect.Top(), aJustifiedRect.Bottom(),
                                       aHorzFilter );

  for ( sal_uInt16 i = 0; i < nSourceSize; i++ )
      aVertFilter.Input( mpImplPolygon->mxPointAry[i] );
  if ( aVertFilter.IsPolygon() )
      aVertFilter.LastPoint();
  else
      aPolygon.LastPoint();

  mpImplPolygon = ImplType(aPolygon.get());
1446}

1448tools::Rectangle Polygon::GetBoundRect() const
1449{
  // Removing the assert. Bezier curves have the attribute that each single
  // curve segment defined by four points can not exit the four-point polygon
  // defined by that points. This allows to say that the curve segment can also
  // never leave the Range of its defining points.
  // The result is that Polygon::GetBoundRect() may not create the minimal
  // BoundRect of the Polygon (to get that, use basegfx::B2DPolygon classes),
  // but will always create a valid BoundRect, at least as long as this method
  // 'blindly' travels over all points, including control points.

  // DBG_ASSERT( !mpImplPolygon->mxFlagAry.get(), "GetBoundRect could fail with beziers!" );

  sal_uInt16  nCount = mpImplPolygon->mnPoints;
  if( ! nCount )
      return tools::Rectangle();

  long    nXMin, nXMax, nYMin, nYMax;

  const Point& pFirstPt = mpImplPolygon->mxPointAry[0];
  nXMin = nXMax = pFirstPt.X();
  nYMin = nYMax = pFirstPt.Y();

  for ( sal_uInt16 i = 0; i < nCount; i++ )
  {
      const Point& rPt = mpImplPolygon->mxPointAry[i];

      if (rPt.X() < nXMin)
          nXMin = rPt.X();
      if (rPt.X() > nXMax)
          nXMax = rPt.X();
      if (rPt.Y() < nYMin)
          nYMin = rPt.Y();
      if (rPt.Y() > nYMax)
          nYMax = rPt.Y();
  }

  return tools::Rectangle( nXMin, nYMin, nXMax, nYMax );
1486}

1488bool Polygon::IsInside( const Point& rPoint ) const
1489{
  DBG_ASSERT( !mpImplPolygon->mxFlagAry, "IsInside could fail with beziers!" )do { if (true && (!(!mpImplPolygon->mxFlagAry))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1490" ": "), "%s", "IsInside could fail with beziers!")
; } } while (false);

  const tools::Rectangle aBound( GetBoundRect() );
  const Line      aLine( rPoint, Point( aBound.Right() + 100, rPoint.Y() ) );
  sal_uInt16          nCount = mpImplPolygon->mnPoints;
  sal_uInt16          nPCounter = 0;

  if ( ( nCount > 2 ) && aBound.IsInside( rPoint ) )
  {
      Point   aPt1( mpImplPolygon->mxPointAry[ 0 ] );
      Point   aIntersection;
      Point   aLastIntersection;

      while ( ( aPt1 == mpImplPolygon->mxPointAry[ nCount - 1 ] ) && ( nCount > 3 ) )
          nCount--;

      for ( sal_uInt16 i = 1; i <= nCount; i++ )
      {
          const Point& rPt2 = mpImplPolygon->mxPointAry[ ( i < nCount ) ? i : 0 ];

          if ( aLine.Intersection( Line( aPt1, rPt2 ), aIntersection ) )
          {
              // This avoids insertion of double intersections
              if ( nPCounter )
              {
                  if ( aIntersection != aLastIntersection )
                  {
                      aLastIntersection = aIntersection;
                      nPCounter++;
                  }
              }
              else
              {
                  aLastIntersection = aIntersection;
                  nPCounter++;
              }
          }

          aPt1 = rPt2;
      }
  }

  // is inside, if number of intersection points is odd
  return ( ( nPCounter & 1 ) == 1 );
1534}

1536void Polygon::Insert( sal_uInt16 nPos, const Point& rPt )
1537{
  if( nPos >= mpImplPolygon->mnPoints )
      nPos = mpImplPolygon->mnPoints;

  if (mpImplPolygon->ImplSplit(nPos, 1))
      mpImplPolygon->mxPointAry[ nPos ] = rPt;
1543}

1545void Polygon::Insert( sal_uInt16 nPos, const tools::Polygon& rPoly )
1546{
  const sal_uInt16 nInsertCount = rPoly.mpImplPolygon->mnPoints;

  if( nInsertCount )
  {
      if( nPos >= mpImplPolygon->mnPoints )
          nPos = mpImplPolygon->mnPoints;

      if (rPoly.mpImplPolygon->mxFlagAry)
          mpImplPolygon->ImplCreateFlagArray();

      mpImplPolygon->ImplSplit( nPos, nInsertCount, rPoly.mpImplPolygon.get() );
  }
1559}

1561Point& Polygon::operator[]( sal_uInt16 nPos )
1562{
  DBG_ASSERT( nPos < mpImplPolygon->mnPoints, "Polygon::[]: nPos >= nPoints" )do { if (true && (!(nPos < mpImplPolygon->mnPoints
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1563" ": "), "%s", "Polygon::[]: nPos >= nPoints"); }
 } while (false);

  return mpImplPolygon->mxPointAry[nPos];
1566}

1568tools::Polygon& Polygon::operator=( const tools::Polygon& rPoly )
1569{
  mpImplPolygon = rPoly.mpImplPolygon;
  return *this;
1572}

1574tools::Polygon& Polygon::operator=( tools::Polygon&& rPoly ) noexcept
1575{
  mpImplPolygon = std::move(rPoly.mpImplPolygon);
  return *this;
1578}

1580bool Polygon::operator==( const tools::Polygon& rPoly ) const
1581{
  return (mpImplPolygon == rPoly.mpImplPolygon);
1583}

1585bool Polygon::IsEqual( const tools::Polygon& rPoly ) const
1586{
  bool bIsEqual = true;
  sal_uInt16 i;
  if ( GetSize() != rPoly.GetSize() )
      bIsEqual = false;
  else
  {
      for ( i = 0; i < GetSize(); i++ )
      {
          if ( ( GetPoint( i ) != rPoly.GetPoint( i ) ) ||
              ( GetFlags( i ) != rPoly.GetFlags( i ) ) )
          {
              bIsEqual = false;
              break;
          }
      }
  }
  return bIsEqual;
1604}

1606SvStream& ReadPolygon( SvStream& rIStream, tools::Polygon& rPoly )
1607{
  sal_uInt16          i;
  sal_uInt16          nPoints(0);

  // read all points and create array
  rIStream.ReadUInt16( nPoints );

  const size_t nMaxRecordsPossible = rIStream.remainingSize() / (2 * sizeof(sal_Int32));
  if (nPoints > nMaxRecordsPossible)
  {
      SAL_WARN("tools", "Polygon claims " << nPoints << " records, but only " << nMaxRecordsPossible << " possible")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "tools")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Polygon claims " << nPoints << " records, but only "
 << nMaxRecordsPossible << " possible") == 1) { ::
sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1617" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Polygon claims " << nPoints <<
 " records, but only " << nMaxRecordsPossible << " possible"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Polygon claims " << nPoints << " records, but only "
 << nMaxRecordsPossible << " possible"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1617" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Polygon claims " << nPoints << " records, but only "
 << nMaxRecordsPossible << " possible") == 1) { ::
sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1617" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Polygon claims " << nPoints <<
 " records, but only " << nMaxRecordsPossible << " possible"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Polygon claims " << nPoints << " records, but only "
 << nMaxRecordsPossible << " possible"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("tools"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1617" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      nPoints = nMaxRecordsPossible;
  }

  rPoly.mpImplPolygon->ImplSetSize( nPoints, false );

  // Determine whether we need to write through operators
1624#if (SAL_TYPES_SIZEOFLONG8) == 4
1625#ifdef OSL_BIGENDIAN
  if ( rIStream.GetEndian() == SvStreamEndian::BIG )
1627#else
  if ( rIStream.GetEndian() == SvStreamEndian::LITTLE )
1629#endif
     rIStream.ReadBytes(rPoly.mpImplPolygon->mxPointAry.get(), nPoints*sizeof(Point));
  else
1632#endif
  {
      for( i = 0; i < nPoints; i++ )
      {
          sal_Int32 nTmpX(0), nTmpY(0);
          rIStream.ReadInt32( nTmpX ).ReadInt32( nTmpY );
          rPoly.mpImplPolygon->mxPointAry[i].setX( nTmpX );
          rPoly.mpImplPolygon->mxPointAry[i].setY( nTmpY );
      }
  }

  return rIStream;
1644}

1646SvStream& WritePolygon( SvStream& rOStream, const tools::Polygon& rPoly )
1647{
  sal_uInt16          i;
  sal_uInt16          nPoints = rPoly.GetSize();

  // Write number of points
  rOStream.WriteUInt16( nPoints );

  // Determine whether we need to write through operators
1655#if (SAL_TYPES_SIZEOFLONG8) == 4
1656#ifdef OSL_BIGENDIAN
  if ( rOStream.GetEndian() == SvStreamEndian::BIG )
1658#else
  if ( rOStream.GetEndian() == SvStreamEndian::LITTLE )
1660#endif
  {
      if ( nPoints )
          rOStream.WriteBytes(rPoly.mpImplPolygon->mxPointAry.get(), nPoints*sizeof(Point));
  }
  else
1666#endif
  {
      for( i = 0; i < nPoints; i++ )
      {
          rOStream.WriteInt32( rPoly.mpImplPolygon->mxPointAry[i].X() )
                  .WriteInt32( rPoly.mpImplPolygon->mxPointAry[i].Y() );
      }
  }

  return rOStream;
1676}

1678void Polygon::ImplRead( SvStream& rIStream )
1679{
  sal_uInt8 bHasPolyFlags(0);

  ReadPolygon( rIStream, *this );
  rIStream.ReadUChar( bHasPolyFlags );

  if ( bHasPolyFlags )
  {
      mpImplPolygon->mxFlagAry.reset(new PolyFlags[mpImplPolygon->mnPoints]);
      rIStream.ReadBytes(mpImplPolygon->mxFlagAry.get(), mpImplPolygon->mnPoints);
  }
1690}

1692void Polygon::Read( SvStream& rIStream )
1693{
  VersionCompat aCompat( rIStream, StreamMode::READ );

  ImplRead( rIStream );
1697}

1699void Polygon::ImplWrite( SvStream& rOStream ) const
1700{
  bool bHasPolyFlags(mpImplPolygon->mxFlagAry);
  WritePolygon( rOStream, *this );
  rOStream.WriteBool(bHasPolyFlags);

  if ( bHasPolyFlags )
      rOStream.WriteBytes(mpImplPolygon->mxFlagAry.get(), mpImplPolygon->mnPoints);
1707}

1709void Polygon::Write( SvStream& rOStream ) const
1710{
  VersionCompat aCompat( rOStream, StreamMode::WRITE, 1 );

  ImplWrite( rOStream );
1714}

1716// #i74631#/#i115917# numerical correction method for B2DPolygon
1717static void impCorrectContinuity(basegfx::B2DPolygon& roPolygon, sal_uInt32 nIndex, PolyFlags nCFlag)
1718{
  const sal_uInt32 nPointCount(roPolygon.count());
  OSL_ENSURE(nIndex < nPointCount, "impCorrectContinuity: index access out of range (!)")do { if (true && (!(nIndex < nPointCount))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1720" ": "), "%s", "impCorrectContinuity: index access out of range (!)"
); } } while (false);

  if(nIndex >= nPointCount || (PolyFlags::Smooth != nCFlag && PolyFlags::Symmetric != nCFlag))
      return;

  if(!roPolygon.isPrevControlPointUsed(nIndex) || !roPolygon.isNextControlPointUsed(nIndex))
      return;

  // #i115917# Patch from osnola (modified, thanks for showing the problem)

  // The correction is needed because an integer polygon with control points
  // is converted to double precision. When C1 or C2 is used the involved vectors
  // may not have the same directions/lengths since these come from integer coordinates
  //  and may have been snapped to different nearest integer coordinates. The snap error
  // is in the range of +-1 in y and y, thus 0.0 <= error <= sqrt(2.0). Nonetheless,
  // it needs to be corrected to be able to detect the continuity in this points
  // correctly.

  // We only have the integer data here (already in double precision form, but no mantissa
  // used), so the best correction is to use:

  // for C1: The longest vector since it potentially has best preserved the original vector.
  //         Even better the sum of the vectors, weighted by their length. This gives the
  //         normal vector addition to get the vector itself, lengths need to be preserved.
  // for C2: The mediated vector(s) since both should be the same, but mirrored

  // extract the point and vectors
  const basegfx::B2DPoint aPoint(roPolygon.getB2DPoint(nIndex));
  const basegfx::B2DVector aNext(roPolygon.getNextControlPoint(nIndex) - aPoint);
  const basegfx::B2DVector aPrev(aPoint - roPolygon.getPrevControlPoint(nIndex));

  // calculate common direction vector, normalize
  const basegfx::B2DVector aDirection(aNext + aPrev);
  const double fDirectionLen = aDirection.getLength();
  if (fDirectionLen == 0.0)
      return;

  if (PolyFlags::Smooth == nCFlag)
  {
      // C1: apply common direction vector, preserve individual lengths
      const double fInvDirectionLen(1.0 / fDirectionLen);
      roPolygon.setNextControlPoint(nIndex, basegfx::B2DPoint(aPoint + (aDirection * (aNext.getLength() * fInvDirectionLen))));
      roPolygon.setPrevControlPoint(nIndex, basegfx::B2DPoint(aPoint - (aDirection * (aPrev.getLength() * fInvDirectionLen))));
  }
  else // PolyFlags::Symmetric
  {
      // C2: get mediated length. Taking half of the unnormalized direction would be
      // an approximation, but not correct.
      const double fMedLength((aNext.getLength() + aPrev.getLength()) * (0.5 / fDirectionLen));
      const basegfx::B2DVector aScaledDirection(aDirection * fMedLength);

      // Bring Direction to correct length and apply
      roPolygon.setNextControlPoint(nIndex, basegfx::B2DPoint(aPoint + aScaledDirection));
      roPolygon.setPrevControlPoint(nIndex, basegfx::B2DPoint(aPoint - aScaledDirection));
  }
1775}

1777// convert to basegfx::B2DPolygon and return
1778basegfx::B2DPolygon Polygon::getB2DPolygon() const
1779{
  basegfx::B2DPolygon aRetval;
  const sal_uInt16 nCount(mpImplPolygon->mnPoints);

  if (nCount)
  {
      if (mpImplPolygon->mxFlagAry)
      {
          // handling for curves. Add start point
          const Point aStartPoint(mpImplPolygon->mxPointAry[0]);
          PolyFlags nPointFlag(mpImplPolygon->mxFlagAry[0]);
          aRetval.append(basegfx::B2DPoint(aStartPoint.X(), aStartPoint.Y()));
          Point aControlA, aControlB;

          for(sal_uInt16 a(1); a < nCount;)
          {
              bool bControlA(false);
              bool bControlB(false);

              if(PolyFlags::Control == mpImplPolygon->mxFlagAry[a])
              {
                  aControlA = mpImplPolygon->mxPointAry[a++];
                  bControlA = true;
              }

              if(a < nCount && PolyFlags::Control == mpImplPolygon->mxFlagAry[a])
              {
                  aControlB = mpImplPolygon->mxPointAry[a++];
                  bControlB = true;
              }

              // assert invalid polygons
              OSL_ENSURE(bControlA == bControlB, "Polygon::getB2DPolygon: Invalid source polygon (!)")do { if (true && (!(bControlA == bControlB))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/tools/source/generic/poly.cxx"
 ":" "1811" ": "), "%s", "Polygon::getB2DPolygon: Invalid source polygon (!)"
); } } while (false);

              if(a < nCount)
              {
                  const Point aEndPoint(mpImplPolygon->mxPointAry[a]);

                  if(bControlA)
                  {
                      // bezier edge, add
                      aRetval.appendBezierSegment(
                          basegfx::B2DPoint(aControlA.X(), aControlA.Y()),
                          basegfx::B2DPoint(aControlB.X(), aControlB.Y()),
                          basegfx::B2DPoint(aEndPoint.X(), aEndPoint.Y()));

                      impCorrectContinuity(aRetval, aRetval.count() - 2, nPointFlag);
                  }
                  else
                  {
                      // no bezier edge, add end point
                      aRetval.append(basegfx::B2DPoint(aEndPoint.X(), aEndPoint.Y()));
                  }

                  nPointFlag = mpImplPolygon->mxFlagAry[a++];
              }
          }

          // if exist, remove double first/last points, set closed and correct control points
          basegfx::utils::checkClosed(aRetval);

          if(aRetval.isClosed())
          {
              // closeWithGeometryChange did really close, so last point(s) were removed.
              // Correct the continuity in the changed point
              impCorrectContinuity(aRetval, 0, mpImplPolygon->mxFlagAry[0]);
          }
      }
      else
      {
          // extra handling for non-curves (most-used case) for speedup
          for(sal_uInt16 a(0); a < nCount; a++)
          {
              // get point and add
              const Point aPoint(mpImplPolygon->mxPointAry[a]);
              aRetval.append(basegfx::B2DPoint(aPoint.X(), aPoint.Y()));
          }

          // set closed flag
          basegfx::utils::checkClosed(aRetval);
      }
  }

  return aRetval;
1863}

1865Polygon::Polygon(const basegfx::B2DPolygon& rPolygon) :  mpImplPolygon(ImplPolygon(rPolygon))
1866{
1867}

1869} // namespace tools

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

←

/home/maarten/src/libreoffice/core/include/o3tl/cow_wrapper.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_O3TL_COW_WRAPPER_HXX
21#define INCLUDED_O3TL_COW_WRAPPER_HXX

23#include <memory>
24#include <osl/interlck.h>

26#include <utility>
27#include <cstddef>

29namespace o3tl
30{
  /** Thread-unsafe refcounting

      This is the default locking policy for cow_wrapper. No
      locking/guarding against concurrent access is performed
      whatsoever.
   */
  struct UnsafeRefCountingPolicy
  {
      typedef std::size_t ref_count_t;
      static void incrementCount( ref_count_t& rCount ) { ++rCount; }
      static bool decrementCount( ref_count_t& rCount ) { return --rCount != 0; }
  };

  /** Thread-safe refcounting

      Use this to have the cow_wrapper refcounting mechanisms employ
      the thread-safe oslInterlockedCount .
   */
  struct ThreadSafeRefCountingPolicy
  {
      typedef oslInterlockedCount ref_count_t;
      static void incrementCount( ref_count_t& rCount ) { osl_atomic_increment(&rCount)__sync_add_and_fetch((&rCount), 1); }
      static bool decrementCount( ref_count_t& rCount )
      {
          if( rCount == 1 ) // caller is already the only/last reference
              return false;
          else
              return osl_atomic_decrement(&rCount)__sync_sub_and_fetch((&rCount), 1) != 0;
      }
  };

  /** Copy-on-write wrapper.

      This template provides copy-on-write semantics for the wrapped
      type: when copying, the operation is performed shallow,
      i.e. different cow_wrapper objects share the same underlying
      instance. Only when accessing the underlying object via
      non-const methods, a unique copy is provided.

      The type parameter <code>T</code> must satisfy the following
      requirements: it must be default-constructible, copyable (it
      need not be assignable), and be of non-reference type. Note
      that, despite the fact that this template provides access to
      the wrapped type via pointer-like methods
      (<code>operator->()</code> and <code>operator*()</code>), it does
      <em>not</em> work like e.g. the std smart pointer wrappers
      (shared_ptr, unique_ptr, etc.). Internally, the cow_wrapper
      holds a by-value instance of the wrapped object. This is to
      avoid one additional heap allocation, and providing access via
      <code>operator->()</code>/<code>operator*()</code> is because
      <code>operator.()</code> cannot be overridden.

      Regarding thread safety: this wrapper is <em>not</em>
      thread-safe per se, because cow_wrapper has no way of
      synchronizing the potentially many different cow_wrapper
      instances, that reference a single shared value_type
      instance. That said, when passing
      <code>ThreadSafeRefCountingPolicy</code> as the
      <code>MTPolicy</code> parameter, accessing a thread-safe
      pointee through multiple cow_wrapper instances might be
      thread-safe, if the individual pointee methods are
      thread-safe, <em>including</em> pointee's copy
      constructor. Any wrapped object that needs external
      synchronisation (e.g. via an external mutex, which arbitrates
      access to object methods, and can be held across multiple
      object method calls) cannot easily be dealt with in a
      thread-safe way, because, as noted, objects are shared behind
      the client's back.

      @attention if one wants to use the pimpl idiom together with
      cow_wrapper (i.e. put an opaque type into the cow_wrapper),
      then <em>all<em> methods in the surrounding class needs to be
      non-inline (<em>including</em> destructor, copy constructor
      and assignment operator).

      @example
      <pre>
108class cow_wrapper_client_impl;

110class cow_wrapper_client
111{
112public:
  cow_wrapper_client();
  cow_wrapper_client( const cow_wrapper_client& );
  cow_wrapper_client( cow_wrapper_client&& );
  ~cow_wrapper_client();

  cow_wrapper_client& operator=( const cow_wrapper_client& );
  cow_wrapper_client& operator=( cow_wrapper_client&& );

  void modify( int nVal );
  int queryUnmodified() const;

124private:
  o3tl::cow_wrapper< cow_wrapper_client_impl > maImpl;
126};
      </pre>
      and the implementation file would look like this:
      <pre>
130class cow_wrapper_client_impl
131{
132public:
  void setValue( int nVal ) { mnValue = nVal; }
  int getValue() const { return mnValue; }

136private:
  int mnValue;
138}

140cow_wrapper_client::cow_wrapper_client() :
  maImpl()
142{
143}
144cow_wrapper_client::cow_wrapper_client( const cow_wrapper_client& rSrc ) :
  maImpl( rSrc.maImpl )
146{
147}
148cow_wrapper_client::cow_wrapper_client( cow_wrapper_client& rSrc ) :
  maImpl( std::move( rSrc.maImpl ) )
150{
151}
152cow_wrapper_client::~cow_wrapper_client()
153{
154}
155cow_wrapper_client& cow_wrapper_client::operator=( const cow_wrapper_client& rSrc )
156{
  maImpl = rSrc.maImpl;
  return *this;
159}
160cow_wrapper_client& cow_wrapper_client::operator=( cow_wrapper_client&& rSrc )
161{
  maImpl = std::move( rSrc.maImpl );
  return *this;
164}
165void cow_wrapper_client::modify( int nVal )
166{
  maImpl->setValue( nVal );
168}
169int cow_wrapper_client::queryUnmodified() const
170{
  return maImpl->getValue();
172}
      </pre>
   */
  template<typename T, class MTPolicy=UnsafeRefCountingPolicy> class cow_wrapper
  {
      /** shared value object - gets cloned before cow_wrapper hands
          out a non-const reference to it
       */
      struct impl_t
      {
          impl_t(const impl_t&) = delete;
          impl_t& operator=(const impl_t&) = delete;

          impl_t() :
              m_value(),
              m_ref_count(1)
          {
          }

          explicit impl_t( const T& v ) :
              m_value(v),
              m_ref_count(1)
          {
          }

          explicit impl_t( T&& v ) :
              m_value(std::move(v)),
              m_ref_count(1)
          {
          }

          T                              m_value;
          typename MTPolicy::ref_count_t m_ref_count;
      };

      void release()
      {
          if( m_pimpl18.1
Field 'm_pimpl' is non-null
1
Field 'm_pimpl' is non-null
 && !MTPolicy::decrementCount(m_pimpl->m_ref_count) )
19
←
Taking true branch→
          {
              delete m_pimpl;
20
←
Memory is released→
              m_pimpl = nullptr;
          }
      }

  public:
      typedef T        value_type;
      typedef T*       pointer;
      typedef const T* const_pointer;
      typedef MTPolicy mt_policy;

      /** Default-construct wrapped type instance
       */
      cow_wrapper() :
          m_pimpl( new impl_t() )
      {
      }

      /** Copy-construct wrapped type instance from given object
       */
      explicit cow_wrapper( const value_type& r ) :
          m_pimpl( new impl_t(r) )
      {
      }

      /** Move-construct wrapped type instance from given object
       */
      explicit cow_wrapper( value_type&& r ) :
          m_pimpl( new impl_t(std::move(r)) )
      {
      }

      /** Shallow-copy given cow_wrapper
       */
      explicit cow_wrapper( const cow_wrapper& rSrc ) : // nothrow
          m_pimpl( rSrc.m_pimpl )
      {
          MTPolicy::incrementCount( m_pimpl->m_ref_count );
      }

      /** Move-construct and steal rSrc shared resource
       */
      explicit cow_wrapper( cow_wrapper&& rSrc ) noexcept :
          m_pimpl( rSrc.m_pimpl )
      {
          rSrc.m_pimpl = nullptr;
      }

      ~cow_wrapper() // nothrow, if ~T does not throw
      {
          release();
18
←
Calling 'cow_wrapper::release'→
21
←
Returning; memory was released→
      }

      /// now sharing rSrc cow_wrapper instance with us
      cow_wrapper& operator=( const cow_wrapper& rSrc ) // nothrow
      {
          // this already guards against self-assignment
          MTPolicy::incrementCount( rSrc.m_pimpl->m_ref_count );

          release();
          m_pimpl = rSrc.m_pimpl;

          return *this;
      }

      /// stealing rSrc's resource
      cow_wrapper& operator=(cow_wrapper&& rSrc) noexcept
      {
          // self-movement guts ourself, see also 17.6.4.9
          release();
          m_pimpl = rSrc.m_pimpl;

          rSrc.m_pimpl = nullptr;

          return *this;
      }

      /// unshare with any other cow_wrapper instance
      value_type& make_unique()
      {
          if( m_pimpl->m_ref_count > 1 )
26
←
Use of memory after it is freed
          {
              impl_t* pimpl = new impl_t(m_pimpl->m_value);
              release();
              m_pimpl = pimpl;
          }

          return m_pimpl->m_value;
      }

      /// true, if not shared with any other cow_wrapper instance
      bool is_unique() const // nothrow
      {
          return !m_pimpl || m_pimpl->m_ref_count == 1;
      }

      /// return number of shared instances (1 for unique object)
      typename MTPolicy::ref_count_t use_count() const // nothrow
      {
          return m_pimpl ? m_pimpl->m_ref_count : 0;
      }

      void swap(cow_wrapper& r) // never throws
      {
          std::swap(m_pimpl, r.m_pimpl);
      }

      pointer           operator->()       { return &make_unique(); }
25
←
Calling 'cow_wrapper::make_unique'→
      value_type&       operator*()        { return make_unique(); }
      const_pointer     operator->() const { return &m_pimpl->m_value; }
      const value_type& operator*()  const { return m_pimpl->m_value; }

      pointer           get()       { return &make_unique(); }
      const_pointer     get() const { return &m_pimpl->m_value; }

      /// true, if both cow_wrapper internally share the same object
      bool              same_object( const cow_wrapper& rOther ) const
      {
          return rOther.m_pimpl == m_pimpl;
      }

  private:
      impl_t* m_pimpl;
  };


  template<class T, class P> inline bool operator==( const cow_wrapper<T,P>& a,
                                                     const cow_wrapper<T,P>& b )
  {
      return a.same_object(b) || *a == *b;
  }

  template<class T, class P> inline bool operator!=( const cow_wrapper<T,P>& a,
                                                     const cow_wrapper<T,P>& b )
  {
      return !a.same_object(b) && *a != *b;
  }

  template<class A, class B, class P> inline bool operator<( const cow_wrapper<A,P>& a,
                                                             const cow_wrapper<B,P>& b )
  {
      return *a < *b;
  }

  template<class T, class P> inline void swap( cow_wrapper<T,P>& a,
                                               cow_wrapper<T,P>& b )
  {
      a.swap(b);
  }

361}

363#endif /* INCLUDED_O3TL_COW_WRAPPER_HXX */

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