[geos-commits] [SCM] geos branch master updated. 8193383d7020b369205c79ba9021e8b1774a84ca
git at osgeo.org
git at osgeo.org
Thu Sep 7 03:28:43 PDT 2017
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "geos".
The branch, master has been updated
via 8193383d7020b369205c79ba9021e8b1774a84ca (commit)
via 50860b7a7466e88510dac92b4c1a568ee807e5c4 (commit)
from b507095ff861fbe8642cd65660bf530e674efb2f (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8193383d7020b369205c79ba9021e8b1774a84ca
Merge: b507095 50860b7
Author: Sandro Santilli <strk at kbt.io>
Date: Thu Sep 7 03:28:43 2017 -0700
Merge branch 'ml/rfc5-cpp11-unique_ptr' of mloskot/geos into master
commit 50860b7a7466e88510dac92b4c1a568ee807e5c4
Author: Mateusz Loskot <mateusz at loskot.net>
Date: Wed Sep 6 22:01:01 2017 +0200
Replace std::auto_ptr with std::unique_ptr
Rename T::AutoPtr to T::Ptr.
Add explicit move of input arguments of unique_ptr type
passed to sink functions.
Add explicit move of values of unique_ptr type
returned from source functions which give up class
member resource.
Comment source functions with:
NOTE: Apparently, this is 'source' method giving up the object resource.
Replace GeometryFactory::unique_ptr with GeometryFactory::Ptr based
on std::unique_ptr with custom GeometryFactoryDeleter.
Remove obscure dynamic_cast_auto_ptr from test utilities.
Part of GEOS RFC 5: C++11 Compilation Mode
diff --git a/capi/geos_c.cpp b/capi/geos_c.cpp
index 66c792a..92fce4c 100644
--- a/capi/geos_c.cpp
+++ b/capi/geos_c.cpp
@@ -80,7 +80,7 @@ using geos::operation::overlay::OverlayOp;
using geos::operation::overlay::overlayOp;
using geos::operation::geounion::CascadedPolygonUnion;
-typedef std::auto_ptr<Geometry> GeomAutoPtr;
+typedef std::unique_ptr<Geometry> GeomPtr;
//## GLOBALS ################################################
diff --git a/capi/geos_ts_c.cpp b/capi/geos_ts_c.cpp
index 1c52237..00e347f 100644
--- a/capi/geos_ts_c.cpp
+++ b/capi/geos_ts_c.cpp
@@ -144,7 +144,7 @@ using geos::util::IllegalArgumentException;
using geos::algorithm::distance::DiscreteHausdorffDistance;
using geos::algorithm::distance::DiscreteFrechetDistance;
-typedef std::auto_ptr<Geometry> GeomAutoPtr;
+typedef std::unique_ptr<Geometry> GeomPtr;
typedef struct GEOSContextHandle_HS
{
@@ -2402,7 +2402,7 @@ GEOSUnaryUnion_r(GEOSContextHandle_t extHandle, const Geometry *g)
try
{
- GeomAutoPtr g3 ( g->Union() );
+ GeomPtr g3 ( g->Union() );
return g3.release();
}
catch (const std::exception &e)
@@ -2441,7 +2441,7 @@ GEOSNode_r(GEOSContextHandle_t extHandle, const Geometry *g)
try
{
- std::auto_ptr<Geometry> g3 = geos::noding::GeometryNoder::node(*g);
+ std::unique_ptr<Geometry> g3 = geos::noding::GeometryNoder::node(*g);
return g3.release();
}
catch (const std::exception &e)
@@ -2560,7 +2560,7 @@ GEOSClipByRect_r(GEOSContextHandle_t extHandle, const Geometry *g, double xmin,
using geos::operation::intersection::Rectangle;
using geos::operation::intersection::RectangleIntersection;
Rectangle rect(xmin, ymin, xmax, ymax);
- std::auto_ptr<Geometry> g3 = RectangleIntersection::clip(*g, rect);
+ std::unique_ptr<Geometry> g3 = RectangleIntersection::clip(*g, rect);
return g3.release();
}
catch (const std::exception &e)
@@ -4551,10 +4551,10 @@ GEOSGeom_setPrecision_r(GEOSContextHandle_t extHandle, const GEOSGeometry *g,
{
const PrecisionModel *pm = g->getPrecisionModel();
double cursize = pm->isFloating() ? 0 : 1.0/pm->getScale();
- std::auto_ptr<PrecisionModel> newpm;
+ std::unique_ptr<PrecisionModel> newpm;
if ( gridSize ) newpm.reset( new PrecisionModel(1.0/gridSize) );
else newpm.reset( new PrecisionModel() );
- GeometryFactory::unique_ptr gf =
+ GeometryFactory::Ptr gf =
GeometryFactory::create( newpm.get(), g->getSRID() );
Geometry *ret;
if ( gridSize && cursize != gridSize )
@@ -4701,7 +4701,7 @@ GEOSSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1, double toleran
try
{
using namespace geos::simplify;
- Geometry::AutoPtr g(DouglasPeuckerSimplifier::simplify(g1, tolerance));
+ Geometry::Ptr g(DouglasPeuckerSimplifier::simplify(g1, tolerance));
return g.release();
}
catch (const std::exception &e)
@@ -4734,7 +4734,7 @@ GEOSTopologyPreserveSimplify_r(GEOSContextHandle_t extHandle, const Geometry *g1
try
{
using namespace geos::simplify;
- Geometry::AutoPtr g(TopologyPreservingSimplifier::simplify(g1, tolerance));
+ Geometry::Ptr g(TopologyPreservingSimplifier::simplify(g1, tolerance));
return g.release();
}
catch (const std::exception &e)
@@ -6578,7 +6578,7 @@ GEOSSharedPaths_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1, const G
const GeometryFactory* factory = g1->getFactory();
size_t count;
- std::auto_ptr< std::vector<Geometry*> > out1(
+ std::unique_ptr< std::vector<Geometry*> > out1(
new std::vector<Geometry*>()
);
count = forw.size();
@@ -6586,11 +6586,11 @@ GEOSSharedPaths_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1, const G
for (size_t i=0; i<count; ++i) {
out1->push_back(forw[i]);
}
- std::auto_ptr<Geometry> out1g (
+ std::unique_ptr<Geometry> out1g (
factory->createMultiLineString(out1.release())
);
- std::auto_ptr< std::vector<Geometry*> > out2(
+ std::unique_ptr< std::vector<Geometry*> > out2(
new std::vector<Geometry*>()
);
count = back.size();
@@ -6598,18 +6598,18 @@ GEOSSharedPaths_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1, const G
for (size_t i=0; i<count; ++i) {
out2->push_back(back[i]);
}
- std::auto_ptr<Geometry> out2g (
+ std::unique_ptr<Geometry> out2g (
factory->createMultiLineString(out2.release())
);
- std::auto_ptr< std::vector<Geometry*> > out(
+ std::unique_ptr< std::vector<Geometry*> > out(
new std::vector<Geometry*>()
);
out->reserve(2);
out->push_back(out1g.release());
out->push_back(out2g.release());
- std::auto_ptr<Geometry> outg (
+ std::unique_ptr<Geometry> outg (
factory->createGeometryCollection(out.release())
);
@@ -6630,7 +6630,7 @@ GEOSSnap_r(GEOSContextHandle_t extHandle, const GEOSGeometry* g1,
try{
GeometrySnapper snapper( *g1 );
- std::auto_ptr<Geometry> ret = snapper.snapTo(*g2, tolerance);
+ std::unique_ptr<Geometry> ret = snapper.snapTo(*g2, tolerance);
return ret.release();
}
catch (const std::exception &e)
diff --git a/doc/example.cpp b/doc/example.cpp
index 1e1c226..0453c7b 100644
--- a/doc/example.cpp
+++ b/doc/example.cpp
@@ -392,7 +392,7 @@ create_arc(double llX, double llY, double width, double height, double startang,
return shapefactory.createArc(startang, endang);
}
-auto_ptr<Polygon>
+unique_ptr<Polygon>
create_sinestar(double cx, double cy, double size, int nArms, double armLenRat)
{
geos::geom::util::SineStarFactory fact(global_factory.get());
diff --git a/include/geos/algorithm/Centroid.h b/include/geos/algorithm/Centroid.h
index ebf0e69..16b7ae8 100644
--- a/include/geos/algorithm/Centroid.h
+++ b/include/geos/algorithm/Centroid.h
@@ -21,7 +21,7 @@
#include <geos/export.h>
#include <geos/geom/Coordinate.h> // for composition
-#include <memory> // for std::auto_ptr
+#include <memory> // for std::unique_ptr
// Forward declarations
namespace geos {
@@ -97,7 +97,7 @@ public:
private:
- std::auto_ptr<geom::Coordinate> areaBasePt;
+ std::unique_ptr<geom::Coordinate> areaBasePt;
geom::Coordinate triangleCent3;
geom::Coordinate cg3;
geom::Coordinate lineCentSum;
diff --git a/include/geos/geom/BinaryOp.h b/include/geos/geom/BinaryOp.h
index af5c74b..015d2f4 100644
--- a/include/geos/geom/BinaryOp.h
+++ b/include/geos/geom/BinaryOp.h
@@ -19,7 +19,7 @@
*
* This file provides a single templated function, taking two
* const Geometry pointers, applying a binary operator to them
- * and returning a result Geometry in an auto_ptr<>.
+ * and returning a result Geometry in an unique_ptr<>.
*
* The binary operator is expected to take two const Geometry pointers
* and return a newly allocated Geometry pointer, possibly throwing
@@ -69,7 +69,7 @@
#include <geos/util/TopologyException.h>
#include <geos/util.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
//#define GEOS_DEBUG_BINARYOP 1
#define GEOS_DEBUG_BINARYOP_PRINT_INVALID 1
@@ -219,8 +219,8 @@ check_valid(const Geometry& g, const std::string& label, bool doThrow=false, boo
*
* May return the input untouched.
*/
-inline std::auto_ptr<Geometry>
-fix_self_intersections(std::auto_ptr<Geometry> g, const std::string& label)
+inline std::unique_ptr<Geometry>
+fix_self_intersections(std::unique_ptr<Geometry> g, const std::string& label)
{
::geos::ignore_unused_variable_warning(label);
#ifdef GEOS_DEBUG_BINARYOP
@@ -269,10 +269,10 @@ fix_self_intersections(std::auto_ptr<Geometry> g, const std::string& label)
/// removal.
///
template <class BinOp>
-std::auto_ptr<Geometry>
+std::unique_ptr<Geometry>
SnapOp(const Geometry* g0, const Geometry *g1, BinOp _Op)
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
//using geos::precision::GeometrySnapper;
using geos::operation::overlay::snap::GeometrySnapper;
@@ -339,10 +339,10 @@ SnapOp(const Geometry* g0, const Geometry *g1, BinOp _Op)
}
template <class BinOp>
-std::auto_ptr<Geometry>
+std::unique_ptr<Geometry>
BinaryOp(const Geometry* g0, const Geometry *g1, BinOp _Op)
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
GeomPtr ret;
geos::util::TopologyException origException;
@@ -497,7 +497,7 @@ BinaryOp(const Geometry* g0, const Geometry *g1, BinOp _Op)
for (double scale=maxScale; scale >= 1; scale /= 10)
{
PrecisionModel pm(scale);
- GeometryFactory::unique_ptr gf = GeometryFactory::create(&pm);
+ GeometryFactory::Ptr gf = GeometryFactory::create(&pm);
#if GEOS_DEBUG_BINARYOP
std::cerr << "Trying with scale " << scale << std::endl;
#endif
diff --git a/include/geos/geom/CoordinateList.h b/include/geos/geom/CoordinateList.h
index 2ca97de..902c007 100644
--- a/include/geos/geom/CoordinateList.h
+++ b/include/geos/geom/CoordinateList.h
@@ -25,7 +25,7 @@
#include <list>
#include <ostream> // for operator<<
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -151,9 +151,9 @@ public:
return coords.erase(first, last);
}
- std::auto_ptr<Coordinate::Vect> toCoordinateArray() const
+ std::unique_ptr<Coordinate::Vect> toCoordinateArray() const
{
- std::auto_ptr<Coordinate::Vect> ret(new Coordinate::Vect);
+ std::unique_ptr<Coordinate::Vect> ret(new Coordinate::Vect);
ret->assign(coords.begin(), coords.end());
return ret;
}
diff --git a/include/geos/geom/CoordinateSequence.h b/include/geos/geom/CoordinateSequence.h
index 0b0ab90..008f891 100644
--- a/include/geos/geom/CoordinateSequence.h
+++ b/include/geos/geom/CoordinateSequence.h
@@ -23,7 +23,7 @@
#include <vector>
#include <iosfwd> // ostream
-#include <memory> // for auto_ptr typedef
+#include <memory> // for unique_ptr typedef
// Forward declarations
namespace geos {
@@ -66,7 +66,7 @@ protected:
public:
- typedef std::auto_ptr<CoordinateSequence> AutoPtr;
+ typedef std::unique_ptr<CoordinateSequence> Ptr;
virtual ~CoordinateSequence() {}
diff --git a/include/geos/geom/Envelope.h b/include/geos/geom/Envelope.h
index 32a410d..d6c0ef4 100644
--- a/include/geos/geom/Envelope.h
+++ b/include/geos/geom/Envelope.h
@@ -62,7 +62,7 @@ public:
friend std::ostream& operator<< (std::ostream& os, const Envelope& o);
- typedef std::auto_ptr<Envelope> AutoPtr;
+ typedef std::unique_ptr<Envelope> Ptr;
/** \brief
* Creates a null <code>Envelope</code>.
diff --git a/include/geos/geom/Geometry.h b/include/geos/geom/Geometry.h
index 75cfd94..d82502a 100644
--- a/include/geos/geom/Geometry.h
+++ b/include/geos/geom/Geometry.h
@@ -171,13 +171,13 @@ public:
friend class GeometryFactory;
/// A vector of const Geometry pointers
- typedef std::vector<const Geometry *> ConstVect;
+ using ConstVect = std::vector<const Geometry *>;
/// A vector of non-const Geometry pointers
- typedef std::vector<Geometry *> NonConstVect;
+ using NonConstVect = std::vector<Geometry *>;
- /// An auto_ptr of Geometry
- typedef std::auto_ptr<Geometry> AutoPtr;
+ /// An unique_ptr of Geometry
+ using Ptr = std::unique_ptr<Geometry> ;
/// Make a deep-copy of this Geometry
virtual Geometry* clone() const=0;
@@ -614,7 +614,7 @@ public:
*
* @see UnaryUnionOp
*/
- AutoPtr Union() const;
+ Ptr Union() const;
// throw(IllegalArgumentException *, TopologyException *);
/**
@@ -765,7 +765,7 @@ public:
protected:
/// The bounding box of this Geometry
- mutable std::auto_ptr<Envelope> envelope;
+ mutable std::unique_ptr<Envelope> envelope;
/// Returns true if the array contains any non-empty Geometrys.
static bool hasNonEmptyElements(const std::vector<Geometry *>* geometries);
@@ -794,7 +794,7 @@ protected:
//virtual void checkEqualPrecisionModel(Geometry *other);
- virtual Envelope::AutoPtr computeEnvelopeInternal() const=0; //Abstract
+ virtual Envelope::Ptr computeEnvelopeInternal() const=0; //Abstract
virtual int compareToSameClass(const Geometry *geom) const=0; //Abstract
@@ -870,11 +870,11 @@ std::string geosversion();
*/
std::string jtsport();
-// We use this instead of std::pair<auto_ptr<Geometry>> because C++11
+// We use this instead of std::pair<unique_ptr<Geometry>> because C++11
// forbids that construct:
// http://lwg.github.com/issues/lwg-closed.html#2068
struct GeomPtrPair {
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
GeomPtr first;
GeomPtr second;
};
diff --git a/include/geos/geom/GeometryCollection.h b/include/geos/geom/GeometryCollection.h
index ae24104..b7b5bbf 100644
--- a/include/geos/geom/GeometryCollection.h
+++ b/include/geos/geom/GeometryCollection.h
@@ -23,14 +23,14 @@
#include <geos/export.h>
#include <geos/geom/Geometry.h> // for inheritance
//#include <geos/platform.h>
-#include <geos/geom/Envelope.h> // for proper use of auto_ptr<>
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/inline.h>
#include <string>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -190,7 +190,7 @@ protected:
std::vector<Geometry *>* geometries;
- Envelope::AutoPtr computeEnvelopeInternal() const;
+ Envelope::Ptr computeEnvelopeInternal() const;
int compareToSameClass(const Geometry *gc) const;
diff --git a/include/geos/geom/GeometryFactory.h b/include/geos/geom/GeometryFactory.h
index 474b4e8..e75560e 100644
--- a/include/geos/geom/GeometryFactory.h
+++ b/include/geos/geom/GeometryFactory.h
@@ -65,35 +65,26 @@ namespace geom { // geos::geom
* It is assumed that input Coordinates meet the given precision.
*/
class GEOS_DLL GeometryFactory {
+private:
+
+ struct GeometryFactoryDeleter
+ {
+ void operator()(GeometryFactory* p) const
+ {
+ p->destroy();
+ }
+ };
+
public:
- // TODO: typedef std::unique_ptr<GeometryFactory,destroy>
- class unique_ptr {
- mutable GeometryFactory *_f;
- public:
- // Copying an auto_unique_ptr transfers ownership
- unique_ptr(const unique_ptr& o): _f(o.release()) {};
- GeometryFactory* release() const { GeometryFactory *f = _f; _f=0; return f; }
- void reset(GeometryFactory* f) { if ( _f ) _f->destroy(); _f = f; }
- // assigning an auto_unique_ptr transfers ownership
- unique_ptr& operator=(const unique_ptr& o) {
- reset( o.release() );
- return *this;
- }
- GeometryFactory* get() const { return _f; }
- GeometryFactory* operator->() const { return _f; }
- GeometryFactory& operator*() { return *_f; };
- unique_ptr(): _f(0) {}
- unique_ptr(GeometryFactory* f): _f(f) {}
- ~unique_ptr() { reset(0); }
- };
+ using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>;
/**
* \brief
* Constructs a GeometryFactory that generates Geometries having a
* floating PrecisionModel and a spatial-reference ID of 0.
*/
- static GeometryFactory::unique_ptr create();
+ static GeometryFactory::Ptr create();
/**
* \brief
@@ -107,7 +98,7 @@ public:
* and must be available for the whole lifetime
* of the GeometryFactory
*/
- static GeometryFactory::unique_ptr create(const PrecisionModel *pm, int newSRID,
+ static GeometryFactory::Ptr create(const PrecisionModel *pm, int newSRID,
CoordinateSequenceFactory *nCoordinateSequenceFactory);
/**
@@ -116,7 +107,7 @@ public:
* given CoordinateSequence implementation, a double-precision floating
* PrecisionModel and a spatial-reference ID of 0.
*/
- static GeometryFactory::unique_ptr create(CoordinateSequenceFactory *nCoordinateSequenceFactory);
+ static GeometryFactory::Ptr create(CoordinateSequenceFactory *nCoordinateSequenceFactory);
/**
* \brief
@@ -126,7 +117,7 @@ public:
*
* @param pm the PrecisionModel to use
*/
- static GeometryFactory::unique_ptr create(const PrecisionModel *pm);
+ static GeometryFactory::Ptr create(const PrecisionModel *pm);
/**
* \brief
@@ -137,14 +128,14 @@ public:
* @param pm the PrecisionModel to use, will be copied internally
* @param newSRID the SRID to use
*/
- static GeometryFactory::unique_ptr create(const PrecisionModel* pm, int newSRID);
+ static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID);
/**
* \brief Copy constructor
*
* @param gf the GeometryFactory to clone from
*/
- static GeometryFactory::unique_ptr create(const GeometryFactory &gf);
+ static GeometryFactory::Ptr create(const GeometryFactory &gf);
/**
* \brief
@@ -224,8 +215,8 @@ public:
/// Construct a LinearRing taking ownership of given arguments
LinearRing* createLinearRing(CoordinateSequence* newCoords) const;
- std::auto_ptr<Geometry> createLinearRing(
- std::auto_ptr<CoordinateSequence> newCoords) const;
+ std::unique_ptr<Geometry> createLinearRing(
+ std::unique_ptr<CoordinateSequence> newCoords) const;
/// Construct a LinearRing with a deep-copy of given arguments
LinearRing* createLinearRing(
@@ -268,13 +259,13 @@ public:
LineString* createLineString() const;
/// Copy a LineString
- std::auto_ptr<LineString> createLineString(const LineString& ls) const;
+ std::unique_ptr<LineString> createLineString(const LineString& ls) const;
/// Construct a LineString taking ownership of given argument
LineString* createLineString(CoordinateSequence* coordinates) const;
- std::auto_ptr<Geometry> createLineString(
- std::auto_ptr<CoordinateSequence> coordinates) const;
+ std::unique_ptr<Geometry> createLineString(
+ std::unique_ptr<CoordinateSequence> coordinates) const;
/// Construct a LineString with a deep-copy of given argument
LineString* createLineString(
@@ -322,7 +313,7 @@ public:
/// @param toofar end iterator
///
template <class T>
- std::auto_ptr<Geometry> buildGeometry(T from, T toofar) const
+ std::unique_ptr<Geometry> buildGeometry(T from, T toofar) const
{
bool isHeterogeneous = false;
size_t count = 0;
@@ -341,12 +332,12 @@ public:
// for the empty geometry, return an empty GeometryCollection
if ( count == 0 ) {
- return std::auto_ptr<Geometry>( createGeometryCollection() );
+ return std::unique_ptr<Geometry>( createGeometryCollection() );
}
// for the single geometry, return a clone
if ( count == 1 ) {
- return std::auto_ptr<Geometry>( (*from)->clone() );
+ return std::unique_ptr<Geometry>( (*from)->clone() );
}
// Now we know it is a collection
@@ -364,20 +355,20 @@ public:
// for an heterogeneous ...
if ( isHeterogeneous ) {
- return std::auto_ptr<Geometry>( createGeometryCollection(fromGeoms) );
+ return std::unique_ptr<Geometry>( createGeometryCollection(fromGeoms) );
}
// At this point we know the collection is not hetereogenous.
if ( dynamic_cast<const Polygon*>(*from) ) {
- return std::auto_ptr<Geometry>( createMultiPolygon(fromGeoms) );
+ return std::unique_ptr<Geometry>( createMultiPolygon(fromGeoms) );
} else if ( dynamic_cast<const LineString*>(*from) ) {
- return std::auto_ptr<Geometry>( createMultiLineString(fromGeoms) );
+ return std::unique_ptr<Geometry>( createMultiLineString(fromGeoms) );
} else if ( dynamic_cast<const Point*>(*from) ) {
- return std::auto_ptr<Geometry>( createMultiPoint(fromGeoms) );
+ return std::unique_ptr<Geometry>( createMultiPoint(fromGeoms) );
}
// FIXME: Why not to throw an exception? --mloskot
assert(0); // buildGeomtry encountered an unkwnon geometry type
- return std::auto_ptr<Geometry>(); // nullptr
+ return std::unique_ptr<Geometry>(); // nullptr
}
/** \brief
diff --git a/include/geos/geom/LineSegment.h b/include/geos/geom/LineSegment.h
index 72ed905..5f5bc58 100644
--- a/include/geos/geom/LineSegment.h
+++ b/include/geos/geom/LineSegment.h
@@ -27,7 +27,7 @@
#include <geos/inline.h>
#include <iostream> // for ostream
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -364,7 +364,7 @@ public:
* @param gf the geometery factory to use
* @return a LineString with the same geometry as this segment
*/
- std::auto_ptr<LineString> toGeometry(const GeometryFactory& gf) const;
+ std::unique_ptr<LineString> toGeometry(const GeometryFactory& gf) const;
};
diff --git a/include/geos/geom/LineString.h b/include/geos/geom/LineString.h
index f7ab2f8..72fa019 100644
--- a/include/geos/geom/LineString.h
+++ b/include/geos/geom/LineString.h
@@ -25,13 +25,13 @@
#include <geos/platform.h> // do we need this ?
#include <geos/geom/Geometry.h> // for inheritance
#include <geos/geom/Lineal.h> // for inheritance
-#include <geos/geom/CoordinateSequence.h> // for proper use of auto_ptr<>
-#include <geos/geom/Envelope.h> // for proper use of auto_ptr<>
+#include <geos/geom/CoordinateSequence.h> // for proper use of unique_ptr<>
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <string>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <geos/inline.h>
@@ -195,12 +195,12 @@ protected:
LineString(CoordinateSequence *pts, const GeometryFactory *newFactory);
/// Hopefully cleaner version of the above
- LineString(CoordinateSequence::AutoPtr pts,
+ LineString(CoordinateSequence::Ptr pts,
const GeometryFactory *newFactory);
- Envelope::AutoPtr computeEnvelopeInternal() const;
+ Envelope::Ptr computeEnvelopeInternal() const;
- CoordinateSequence::AutoPtr points;
+ CoordinateSequence::Ptr points;
private:
diff --git a/include/geos/geom/LinearRing.h b/include/geos/geom/LinearRing.h
index d763965..873dd8a 100644
--- a/include/geos/geom/LinearRing.h
+++ b/include/geos/geom/LinearRing.h
@@ -82,7 +82,7 @@ public:
const GeometryFactory *newFactory);
/// Hopefully cleaner version of the above
- LinearRing(CoordinateSequence::AutoPtr points,
+ LinearRing(CoordinateSequence::Ptr points,
const GeometryFactory *newFactory);
virtual Geometry *clone() const { return new LinearRing(*this); }
diff --git a/include/geos/geom/Point.h b/include/geos/geom/Point.h
index bc34963..14a5956 100644
--- a/include/geos/geom/Point.h
+++ b/include/geos/geom/Point.h
@@ -25,15 +25,15 @@
#include <geos/platform.h>
#include <geos/geom/Geometry.h> // for inheritance
#include <geos/geom/Puntal.h> // for inheritance
-#include <geos/geom/CoordinateSequence.h> // for proper use of auto_ptr<>
-#include <geos/geom/Envelope.h> // for proper use of auto_ptr<>
+#include <geos/geom/CoordinateSequence.h> // for proper use of unique_ptr<>
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/inline.h>
#include <string>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -155,7 +155,7 @@ protected:
Point(const Point &p);
- Envelope::AutoPtr computeEnvelopeInternal() const;
+ Envelope::Ptr computeEnvelopeInternal() const;
int compareToSameClass(const Geometry *p) const;
@@ -164,7 +164,7 @@ private:
/**
* The <code>Coordinate</code> wrapped by this <code>Point</code>.
*/
- std::auto_ptr<CoordinateSequence> coordinates;
+ std::unique_ptr<CoordinateSequence> coordinates;
};
} // namespace geos::geom
diff --git a/include/geos/geom/Polygon.h b/include/geos/geom/Polygon.h
index 834b857..500a384 100644
--- a/include/geos/geom/Polygon.h
+++ b/include/geos/geom/Polygon.h
@@ -27,12 +27,12 @@
#include <geos/platform.h>
#include <geos/geom/Geometry.h> // for inheritance
#include <geos/geom/Polygonal.h> // for inheritance
-#include <geos/geom/Envelope.h> // for proper use of auto_ptr<>
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/inline.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -182,7 +182,7 @@ protected:
std::vector<Geometry *> *holes; //Actually vector<LinearRing *>
- Envelope::AutoPtr computeEnvelopeInternal() const;
+ Envelope::Ptr computeEnvelopeInternal() const;
private:
diff --git a/include/geos/geom/util/GeometryTransformer.h b/include/geos/geom/util/GeometryTransformer.h
index e98d9d7..410feea 100644
--- a/include/geos/geom/util/GeometryTransformer.h
+++ b/include/geos/geom/util/GeometryTransformer.h
@@ -23,10 +23,10 @@
#include <geos/export.h>
#include <geos/geom/Coordinate.h> // destructor visibility for vector
-#include <geos/geom/Geometry.h> // destructor visibility for auto_ptr
-#include <geos/geom/CoordinateSequence.h> // destructor visibility for auto_ptr
+#include <geos/geom/Geometry.h> // destructor visibility for unique_ptr
+#include <geos/geom/CoordinateSequence.h> // destructor visibility for unique_ptr
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <vector>
// Forward declarations
@@ -97,7 +97,7 @@ public:
virtual ~GeometryTransformer();
- std::auto_ptr<Geometry> transform(const Geometry* nInputGeom);
+ std::unique_ptr<Geometry> transform(const Geometry* nInputGeom);
void setSkipTransformedInvalidInteriorRings(bool b);
@@ -114,42 +114,42 @@ protected:
*
* [final]
*/
- CoordinateSequence::AutoPtr createCoordinateSequence(
- std::auto_ptr< std::vector<Coordinate> > coords);
+ CoordinateSequence::Ptr createCoordinateSequence(
+ std::unique_ptr< std::vector<Coordinate> > coords);
- virtual CoordinateSequence::AutoPtr transformCoordinates(
+ virtual CoordinateSequence::Ptr transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent);
- virtual Geometry::AutoPtr transformPoint(
+ virtual Geometry::Ptr transformPoint(
const Point* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformMultiPoint(
+ virtual Geometry::Ptr transformMultiPoint(
const MultiPoint* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformLinearRing(
+ virtual Geometry::Ptr transformLinearRing(
const LinearRing* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformLineString(
+ virtual Geometry::Ptr transformLineString(
const LineString* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformMultiLineString(
+ virtual Geometry::Ptr transformMultiLineString(
const MultiLineString* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformPolygon(
+ virtual Geometry::Ptr transformPolygon(
const Polygon* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformMultiPolygon(
+ virtual Geometry::Ptr transformMultiPolygon(
const MultiPolygon* geom,
const Geometry* parent);
- virtual Geometry::AutoPtr transformGeometryCollection(
+ virtual Geometry::Ptr transformGeometryCollection(
const GeometryCollection* geom,
const Geometry* parent);
diff --git a/include/geos/geom/util/SineStarFactory.h b/include/geos/geom/util/SineStarFactory.h
index 582a0d5..03c1b8c 100644
--- a/include/geos/geom/util/SineStarFactory.h
+++ b/include/geos/geom/util/SineStarFactory.h
@@ -106,7 +106,7 @@ public:
*
* @return the geometry representing the sine star
*/
- std::auto_ptr<Polygon> createSineStar() const;
+ std::unique_ptr<Polygon> createSineStar() const;
};
diff --git a/include/geos/geomgraph/GeometryGraph.h b/include/geos/geomgraph/GeometryGraph.h
index 7e76dca..72224a6 100644
--- a/include/geos/geomgraph/GeometryGraph.h
+++ b/include/geos/geomgraph/GeometryGraph.h
@@ -28,7 +28,7 @@
#include <memory>
#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.h> // for auto_ptr<CoordinateSequence>
+#include <geos/geom/CoordinateSequence.h> // for unique_ptr<CoordinateSequence>
#include <geos/geomgraph/PlanarGraph.h>
#include <geos/geom/LineString.h> // for LineStringLT
@@ -105,9 +105,9 @@ private:
int argIndex;
/// Cache for fast responses to getBoundaryPoints
- std::auto_ptr< geom::CoordinateSequence > boundaryPoints;
+ std::unique_ptr< geom::CoordinateSequence > boundaryPoints;
- std::auto_ptr< std::vector<Node*> > boundaryNodes;
+ std::unique_ptr< std::vector<Node*> > boundaryNodes;
bool hasTooFewPointsVar;
diff --git a/include/geos/index/chain/MonotoneChain.h b/include/geos/index/chain/MonotoneChain.h
index a0b8801..97457c3 100644
--- a/include/geos/index/chain/MonotoneChain.h
+++ b/include/geos/index/chain/MonotoneChain.h
@@ -22,7 +22,7 @@
#include <geos/export.h>
#include <geos/geom/Envelope.h> // for inline
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -119,7 +119,7 @@ public:
* Allocates a new CoordinateSequence to hold the Coordinates
*
*/
- std::auto_ptr<geom::CoordinateSequence> getCoordinates() const;
+ std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
/**
* Determine all the line segments in the chain whose envelopes overlap
diff --git a/include/geos/index/quadtree/Node.h b/include/geos/index/quadtree/Node.h
index f37aacf..76f4fd4 100644
--- a/include/geos/index/quadtree/Node.h
+++ b/include/geos/index/quadtree/Node.h
@@ -57,7 +57,7 @@ class GEOS_DLL Node: public NodeBase {
private:
/// Owned by this class
- std::auto_ptr<geom::Envelope> env;
+ std::unique_ptr<geom::Envelope> env;
geom::Coordinate centre;
@@ -71,7 +71,7 @@ private:
*/
Node* getSubnode(int index);
- std::auto_ptr<Node> createSubnode(int index);
+ std::unique_ptr<Node> createSubnode(int index);
protected:
@@ -82,19 +82,19 @@ protected:
public:
// Create a node computing level from given envelope
- static std::auto_ptr<Node> createNode(const geom::Envelope& env);
+ static std::unique_ptr<Node> createNode(const geom::Envelope& env);
/// Create a node containing the given node and envelope
//
/// @param node if not null, will be inserted to the returned node
/// @param addEnv minimum envelope to use for the node
///
- static std::auto_ptr<Node> createExpanded(std::auto_ptr<Node> node,
+ static std::unique_ptr<Node> createExpanded(std::unique_ptr<Node> node,
const geom::Envelope& addEnv);
- Node(std::auto_ptr<geom::Envelope> nenv, int nlevel)
+ Node(std::unique_ptr<geom::Envelope> nenv, int nlevel)
:
- env(nenv),
+ env(std::move(nenv)),
centre((env->getMinX()+env->getMaxX())/2,
(env->getMinY()+env->getMaxY())/2),
level(nlevel)
@@ -120,7 +120,7 @@ public:
*/
NodeBase* find(const geom::Envelope *searchEnv);
- void insertNode(std::auto_ptr<Node> node);
+ void insertNode(std::unique_ptr<Node> node);
std::string toString() const;
diff --git a/include/geos/index/strtree/AbstractSTRtree.h b/include/geos/index/strtree/AbstractSTRtree.h
index d2a9ad2..bb4ddb1 100644
--- a/include/geos/index/strtree/AbstractSTRtree.h
+++ b/include/geos/index/strtree/AbstractSTRtree.h
@@ -21,7 +21,7 @@
#include <vector>
#include <list>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cassert> // for inlines
#include <algorithm>
@@ -149,7 +149,7 @@ private:
BoundableList* boundablesOfALevel,
int level);
- virtual std::auto_ptr<BoundableList> sortBoundables(const BoundableList* input)=0;
+ virtual std::unique_ptr<BoundableList> sortBoundables(const BoundableList* input)=0;
bool remove(const void* searchBounds, AbstractNode& node, void* item);
bool removeItem(AbstractNode& node, void* item);
@@ -183,14 +183,14 @@ protected:
std::vector <AbstractNode *> *nodes;
- // Ownership to caller (TODO: return by auto_ptr)
+ // Ownership to caller (TODO: return by unique_ptr)
virtual AbstractNode* createNode(int level)=0;
/**
* Sorts the childBoundables then divides them into groups of size M, where
* M is the node capacity.
*/
- virtual std::auto_ptr<BoundableList> createParentBoundables(
+ virtual std::unique_ptr<BoundableList> createParentBoundables(
BoundableList* childBoundables, int newLevel);
virtual AbstractNode* lastNode(BoundableList* nodeList)
@@ -227,7 +227,7 @@ protected:
/// Also builds the tree, if necessary.
bool remove(const void* itemEnv, void* item);
- std::auto_ptr<BoundableList> boundablesAtLevel(int level);
+ std::unique_ptr<BoundableList> boundablesAtLevel(int level);
// @@ should be size_t, probably
std::size_t nodeCapacity;
diff --git a/include/geos/index/strtree/SIRtree.h b/include/geos/index/strtree/SIRtree.h
index 3df520a..dc09da8 100644
--- a/include/geos/index/strtree/SIRtree.h
+++ b/include/geos/index/strtree/SIRtree.h
@@ -88,14 +88,14 @@ protected:
* Sorts the childBoundables then divides them into groups of size M, where
* M is the node capacity.
*/
- std::auto_ptr<BoundableList> createParentBoundables(
+ std::unique_ptr<BoundableList> createParentBoundables(
BoundableList* childBoundables, int newLevel);
AbstractNode* createNode(int level);
IntersectsOp* getIntersectsOp() {return intersectsOp;}
- std::auto_ptr<BoundableList> sortBoundables(const BoundableList* input);
+ std::unique_ptr<BoundableList> sortBoundables(const BoundableList* input);
private:
diff --git a/include/geos/index/strtree/STRtree.h b/include/geos/index/strtree/STRtree.h
index 4f87799..6f49bc8 100644
--- a/include/geos/index/strtree/STRtree.h
+++ b/include/geos/index/strtree/STRtree.h
@@ -79,15 +79,15 @@ private:
* group them into runs of size M (the node capacity). For each run, creates
* a new (parent) node.
*/
- std::auto_ptr<BoundableList> createParentBoundables(BoundableList* childBoundables, int newLevel);
+ std::unique_ptr<BoundableList> createParentBoundables(BoundableList* childBoundables, int newLevel);
- std::auto_ptr<BoundableList> createParentBoundablesFromVerticalSlices(std::vector<BoundableList*>* verticalSlices, int newLevel);
+ std::unique_ptr<BoundableList> createParentBoundablesFromVerticalSlices(std::vector<BoundableList*>* verticalSlices, int newLevel);
STRIntersectsOp intersectsOp;
- std::auto_ptr<BoundableList> sortBoundables(const BoundableList* input);
+ std::unique_ptr<BoundableList> sortBoundables(const BoundableList* input);
- std::auto_ptr<BoundableList> createParentBoundablesFromVerticalSlice(
+ std::unique_ptr<BoundableList> createParentBoundablesFromVerticalSlice(
BoundableList* childBoundables,
int newLevel);
diff --git a/include/geos/linearref/LinearLocation.h b/include/geos/linearref/LinearLocation.h
index 66f1b67..fb0a74a 100644
--- a/include/geos/linearref/LinearLocation.h
+++ b/include/geos/linearref/LinearLocation.h
@@ -22,7 +22,7 @@
#define GEOS_LINEARREF_LINEARLOCATION_H
#include <string>
-#include <memory> // for std::auto_ptr
+#include <memory> // for std::unique_ptr
#include <geos/geom/Coordinate.h>
#include <geos/geom/Geometry.h>
@@ -168,7 +168,7 @@ public:
* @param linearGeom a linear geometry
* @return the <tt>LineSegment</tt> containing the location
*/
- std::auto_ptr<geom::LineSegment> getSegment(const geom::Geometry* linearGeom) const;
+ std::unique_ptr<geom::LineSegment> getSegment(const geom::Geometry* linearGeom) const;
/**
* Tests whether this location refers to a valid
diff --git a/include/geos/noding/FastNodingValidator.h b/include/geos/noding/FastNodingValidator.h
index 18edb80..15e2288 100644
--- a/include/geos/noding/FastNodingValidator.h
+++ b/include/geos/noding/FastNodingValidator.h
@@ -98,7 +98,7 @@ private:
std::vector<noding::SegmentString*>& segStrings;
- std::auto_ptr<SingleInteriorIntersectionFinder> segInt;
+ std::unique_ptr<SingleInteriorIntersectionFinder> segInt;
bool isValidVar;
diff --git a/include/geos/noding/GeometryNoder.h b/include/geos/noding/GeometryNoder.h
index 3bbc3e6..af8a790 100644
--- a/include/geos/noding/GeometryNoder.h
+++ b/include/geos/noding/GeometryNoder.h
@@ -22,7 +22,7 @@
#include <geos/export.h>
#include <geos/noding/SegmentString.h> // for NonConstVect
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -41,11 +41,11 @@ class GEOS_DLL GeometryNoder
{
public:
- static std::auto_ptr<geom::Geometry> node(const geom::Geometry& geom);
+ static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom);
GeometryNoder(const geom::Geometry& g);
- std::auto_ptr<geom::Geometry> getNoded();
+ std::unique_ptr<geom::Geometry> getNoded();
private:
@@ -58,9 +58,9 @@ private:
Noder& getNoder();
- std::auto_ptr<Noder> noder;
+ std::unique_ptr<Noder> noder;
- std::auto_ptr<geom::Geometry> toGeometry(SegmentString::NonConstVect& noded);
+ std::unique_ptr<geom::Geometry> toGeometry(SegmentString::NonConstVect& noded);
GeometryNoder(GeometryNoder const&); /*= delete*/
GeometryNoder& operator=(GeometryNoder const&); /*= delete*/
diff --git a/include/geos/noding/snapround/HotPixel.h b/include/geos/noding/snapround/HotPixel.h
index 73e0938..3f613c9 100644
--- a/include/geos/noding/snapround/HotPixel.h
+++ b/include/geos/noding/snapround/HotPixel.h
@@ -24,7 +24,7 @@
#include <geos/inline.h>
#include <geos/geom/Coordinate.h> // for composition
-#include <geos/geom/Envelope.h> // for auto_ptr
+#include <geos/geom/Envelope.h> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -89,7 +89,7 @@ private:
std::vector<geom::Coordinate> corner;
/// Owned by this class, constructed on demand
- mutable std::auto_ptr<geom::Envelope> safeEnv;
+ mutable std::unique_ptr<geom::Envelope> safeEnv;
void initCorners(const geom::Coordinate& pt);
diff --git a/include/geos/noding/snapround/MCIndexSnapRounder.h b/include/geos/noding/snapround/MCIndexSnapRounder.h
index 5bb38b6..8fa377f 100644
--- a/include/geos/noding/snapround/MCIndexSnapRounder.h
+++ b/include/geos/noding/snapround/MCIndexSnapRounder.h
@@ -79,7 +79,7 @@ public:
:
pm(nPm),
scaleFactor(nPm.getScale()),
- pointSnapper(0)
+ pointSnapper(nullptr)
{
li.setPrecisionModel(&pm);
}
@@ -111,7 +111,7 @@ private:
std::vector<SegmentString*>* nodedSegStrings;
- std::auto_ptr<MCIndexPointSnapper> pointSnapper;
+ std::unique_ptr<MCIndexPointSnapper> pointSnapper;
void snapRound(MCIndexNoder& noder, std::vector<SegmentString*>* segStrings);
diff --git a/include/geos/operation/IsSimpleOp.h b/include/geos/operation/IsSimpleOp.h
index a48f365..8375e25 100644
--- a/include/geos/operation/IsSimpleOp.h
+++ b/include/geos/operation/IsSimpleOp.h
@@ -22,10 +22,10 @@
#define GEOS_OPERATION_ISSIMPLEOP_H
#include <geos/export.h>
-#include <geos/geom/Coordinate.h> // for dtor visibility by auto_ptr (compos)
+#include <geos/geom/Coordinate.h> // for dtor visibility by unique_ptr (compos)
#include <map>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -206,7 +206,7 @@ private:
const geom::Geometry* geom;
- std::auto_ptr<geom::Coordinate> nonSimpleLocation;
+ std::unique_ptr<geom::Coordinate> nonSimpleLocation;
};
} // namespace geos.operation
diff --git a/include/geos/operation/buffer/BufferInputLineSimplifier.h b/include/geos/operation/buffer/BufferInputLineSimplifier.h
index 81d9a1c..297e46b 100644
--- a/include/geos/operation/buffer/BufferInputLineSimplifier.h
+++ b/include/geos/operation/buffer/BufferInputLineSimplifier.h
@@ -87,7 +87,7 @@ public:
* @param distanceTol simplification distance tolerance to use
* @return a simplified version of the coordinate sequence
*/
- static std::auto_ptr<geom::CoordinateSequence> simplify(
+ static std::unique_ptr<geom::CoordinateSequence> simplify(
const geom::CoordinateSequence& inputLine, double distanceTol);
BufferInputLineSimplifier(const geom::CoordinateSequence& input);
@@ -102,7 +102,7 @@ public:
* @param distanceTol simplification distance tolerance to use
* @return the simplified coordinate list
*/
- std::auto_ptr<geom::CoordinateSequence> simplify(double distanceTol);
+ std::unique_ptr<geom::CoordinateSequence> simplify(double distanceTol);
private:
@@ -124,7 +124,7 @@ private:
*/
unsigned int findNextNonDeletedIndex(unsigned int index) const;
- std::auto_ptr<geom::CoordinateSequence> collapseLine() const;
+ std::unique_ptr<geom::CoordinateSequence> collapseLine() const;
bool isDeletable(int i0, int i1, int i2, double distanceTol) const;
diff --git a/include/geos/operation/buffer/OffsetCurveBuilder.h b/include/geos/operation/buffer/OffsetCurveBuilder.h
index 1c6e638..c8dbe71 100644
--- a/include/geos/operation/buffer/OffsetCurveBuilder.h
+++ b/include/geos/operation/buffer/OffsetCurveBuilder.h
@@ -26,7 +26,7 @@
#include <geos/operation/buffer/OffsetSegmentGenerator.h>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -168,7 +168,7 @@ private:
void computeRingBufferCurve(const geom::CoordinateSequence& inputPts,
int side, OffsetSegmentGenerator& segGen);
- std::auto_ptr<OffsetSegmentGenerator> getSegGen(double dist);
+ std::unique_ptr<OffsetSegmentGenerator> getSegGen(double dist);
void computePointCurve(const geom::Coordinate& pt,
OffsetSegmentGenerator& segGen);
diff --git a/include/geos/operation/distance/DistanceOp.h b/include/geos/operation/distance/DistanceOp.h
index 62b5736..de6110d 100644
--- a/include/geos/operation/distance/DistanceOp.h
+++ b/include/geos/operation/distance/DistanceOp.h
@@ -215,7 +215,7 @@ private:
// working
algorithm::PointLocator ptLocator;
- // TODO: use auto_ptr
+ // TODO: use unique_ptr
std::vector<GeometryLocation*> *minDistanceLocation;
double minDistance;
diff --git a/include/geos/operation/distance/IndexedFacetDistance.h b/include/geos/operation/distance/IndexedFacetDistance.h
index a819662..5068b33 100644
--- a/include/geos/operation/distance/IndexedFacetDistance.h
+++ b/include/geos/operation/distance/IndexedFacetDistance.h
@@ -37,7 +37,7 @@ namespace geos {
~IndexedFacetDistance();
private:
- std::auto_ptr<geos::index::strtree::STRtree> cachedTree;
+ std::unique_ptr<geos::index::strtree::STRtree> cachedTree;
};
}
diff --git a/include/geos/operation/intersection/RectangleIntersection.h b/include/geos/operation/intersection/RectangleIntersection.h
index a3470f4..673ab27 100644
--- a/include/geos/operation/intersection/RectangleIntersection.h
+++ b/include/geos/operation/intersection/RectangleIntersection.h
@@ -83,7 +83,7 @@ class GEOS_DLL RectangleIntersection
* @return the clipped geometry
* @return NULL if the geometry is outside the {@link Rectangle}
*/
- static std::auto_ptr<geom::Geometry> clip(const geom::Geometry & geom,
+ static std::unique_ptr<geom::Geometry> clip(const geom::Geometry & geom,
const Rectangle & rect);
/**
@@ -98,16 +98,16 @@ class GEOS_DLL RectangleIntersection
* @return the clipped geometry
* @return NULL if the geometry is outside the {@link Rectangle}
*/
- static std::auto_ptr<geom::Geometry> clipBoundary(const geom::Geometry & geom,
+ static std::unique_ptr<geom::Geometry> clipBoundary(const geom::Geometry & geom,
const Rectangle & rect);
private:
RectangleIntersection(const geom::Geometry& geom, const Rectangle& rect);
- std::auto_ptr<geom::Geometry> clipBoundary();
+ std::unique_ptr<geom::Geometry> clipBoundary();
- std::auto_ptr<geom::Geometry> clip();
+ std::unique_ptr<geom::Geometry> clip();
const geom::Geometry &_geom;
const Rectangle &_rect;
diff --git a/include/geos/operation/intersection/RectangleIntersectionBuilder.h b/include/geos/operation/intersection/RectangleIntersectionBuilder.h
index 865b626..154444b 100644
--- a/include/geos/operation/intersection/RectangleIntersectionBuilder.h
+++ b/include/geos/operation/intersection/RectangleIntersectionBuilder.h
@@ -74,7 +74,7 @@ private:
/**
* \brief Build the result geometry from partial results and clean up
*/
- std::auto_ptr<geom::Geometry> build();
+ std::unique_ptr<geom::Geometry> build();
/**
* \brief Build polygons from parts left by clipping one
diff --git a/include/geos/operation/linemerge/LineSequencer.h b/include/geos/operation/linemerge/LineSequencer.h
index f7d4c01..8dfd9a1 100644
--- a/include/geos/operation/linemerge/LineSequencer.h
+++ b/include/geos/operation/linemerge/LineSequencer.h
@@ -28,7 +28,7 @@
#include <vector>
#include <list>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -106,7 +106,7 @@ private:
const geom::GeometryFactory *factory;
unsigned int lineCount;
bool isRun;
- std::auto_ptr<geom::Geometry> sequencedGeometry;
+ std::unique_ptr<geom::Geometry> sequencedGeometry;
bool isSequenceableVar;
void addLine(const geom::LineString *lineString);
@@ -205,7 +205,7 @@ public:
factory(0),
lineCount(0),
isRun(false),
- sequencedGeometry(0),
+ sequencedGeometry(nullptr),
isSequenceableVar(false)
{}
diff --git a/include/geos/operation/overlay/snap/GeometrySnapper.h b/include/geos/operation/overlay/snap/GeometrySnapper.h
index 61487b7..4fbe2ae 100644
--- a/include/geos/operation/overlay/snap/GeometrySnapper.h
+++ b/include/geos/operation/overlay/snap/GeometrySnapper.h
@@ -59,7 +59,7 @@ class GEOS_DLL GeometrySnapper {
public:
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
/**
* Snaps two geometries together with a given tolerance.
@@ -67,7 +67,7 @@ public:
* @param g0 a geometry to snap
* @param g1 a geometry to snap
* @param snapTolerance the tolerance to use
- * @param ret the snapped geometries as a pair of auto_ptrs
+ * @param ret the snapped geometries as a pair of smart pointers
* (output parameter)
*/
static void snap(const geom::Geometry& g0,
@@ -97,7 +97,7 @@ public:
* @param snapTolerance
* @return a new snapped Geometry
*/
- std::auto_ptr<geom::Geometry> snapTo(const geom::Geometry& g,
+ std::unique_ptr<geom::Geometry> snapTo(const geom::Geometry& g,
double snapTolerance);
/** \brief
@@ -109,7 +109,7 @@ public:
* @param cleanResult clean the result
* @return a new snapped Geometry
*/
- std::auto_ptr<geom::Geometry> snapToSelf(double snapTolerance,
+ std::unique_ptr<geom::Geometry> snapToSelf(double snapTolerance,
bool cleanResult);
/** \brief
@@ -140,7 +140,7 @@ private:
const geom::Geometry& srcGeom;
/// Extract target (unique) coordinates
- std::auto_ptr<geom::Coordinate::ConstVect> extractTargetCoordinates(
+ std::unique_ptr<geom::Coordinate::ConstVect> extractTargetCoordinates(
const geom::Geometry& g);
// Declare type as noncopyable
diff --git a/include/geos/operation/overlay/snap/LineStringSnapper.h b/include/geos/operation/overlay/snap/LineStringSnapper.h
index 7658be0..d530b23 100644
--- a/include/geos/operation/overlay/snap/LineStringSnapper.h
+++ b/include/geos/operation/overlay/snap/LineStringSnapper.h
@@ -71,7 +71,7 @@ public:
}
// Snap points are assumed to be all distinct points (a set would be better, uh ?)
- std::auto_ptr<geom::Coordinate::Vect> snapTo(const geom::Coordinate::ConstVect& snapPts);
+ std::unique_ptr<geom::Coordinate::Vect> snapTo(const geom::Coordinate::ConstVect& snapPts);
void setAllowSnappingToSourceVertices(bool allow) {
allowSnappingToSourceVertices = allow;
diff --git a/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h b/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
index c7f19b0..823ac30 100644
--- a/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
+++ b/include/geos/operation/overlay/snap/SnapIfNeededOverlayOp.h
@@ -21,7 +21,7 @@
#include <geos/operation/overlay/OverlayOp.h> // for enums
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -51,7 +51,7 @@ class SnapIfNeededOverlayOp
public:
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
overlayOp(const geom::Geometry& g0, const geom::Geometry& g1,
OverlayOp::OpCode opCode)
{
@@ -59,25 +59,25 @@ public:
return op.getResultGeometry(opCode);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
intersection(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opINTERSECTION);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
Union(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opUNION);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
difference(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opDIFFERENCE);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
symDifference(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opSYMDIFFERENCE);
@@ -91,7 +91,7 @@ public:
}
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
GeomPtr getResultGeometry(OverlayOp::OpCode opCode);
diff --git a/include/geos/operation/overlay/snap/SnapOverlayOp.h b/include/geos/operation/overlay/snap/SnapOverlayOp.h
index 93e5319..7be8811 100644
--- a/include/geos/operation/overlay/snap/SnapOverlayOp.h
+++ b/include/geos/operation/overlay/snap/SnapOverlayOp.h
@@ -20,9 +20,9 @@
#define GEOS_OP_OVERLAY_SNAP_SNAPOVERLAYOP_H
#include <geos/operation/overlay/OverlayOp.h> // for enums
-#include <geos/precision/CommonBitsRemover.h> // for dtor visibility by auto_ptr
+#include <geos/precision/CommonBitsRemover.h> // for dtor visibility by unique_ptr
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -58,7 +58,7 @@ class GEOS_DLL SnapOverlayOp
public:
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
overlayOp(const geom::Geometry& g0, const geom::Geometry& g1,
OverlayOp::OpCode opCode)
{
@@ -66,25 +66,25 @@ public:
return op.getResultGeometry(opCode);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
intersection(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opINTERSECTION);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
Union(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opUNION);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
difference(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opDIFFERENCE);
}
- static std::auto_ptr<geom::Geometry>
+ static std::unique_ptr<geom::Geometry>
symDifference(const geom::Geometry& g0, const geom::Geometry& g1)
{
return overlayOp(g0, g1, OverlayOp::opSYMDIFFERENCE);
@@ -99,7 +99,7 @@ public:
}
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
GeomPtr getResultGeometry(OverlayOp::OpCode opCode);
@@ -122,7 +122,7 @@ private:
double snapTolerance;
- std::auto_ptr<precision::CommonBitsRemover> cbr;
+ std::unique_ptr<precision::CommonBitsRemover> cbr;
// Declare type as noncopyable
SnapOverlayOp(const SnapOverlayOp& other);
diff --git a/include/geos/operation/overlay/validate/FuzzyPointLocator.h b/include/geos/operation/overlay/validate/FuzzyPointLocator.h
index f9e68e8..7856372 100644
--- a/include/geos/operation/overlay/validate/FuzzyPointLocator.h
+++ b/include/geos/operation/overlay/validate/FuzzyPointLocator.h
@@ -21,11 +21,11 @@
#include <geos/export.h>
#include <geos/algorithm/PointLocator.h> // for composition
-#include <geos/geom/Geometry.h> // for auto_ptr visibility of dtor
+#include <geos/geom/Geometry.h> // for unique_ptr visibility of dtor
#include <geos/geom/Location.h> // for Location::Value enum
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -71,16 +71,16 @@ private:
algorithm::PointLocator ptLocator;
- std::auto_ptr<geom::Geometry> linework;
+ std::unique_ptr<geom::Geometry> linework;
// this function has been obsoleted
- std::auto_ptr<geom::Geometry> getLineWork(const geom::Geometry& geom);
+ std::unique_ptr<geom::Geometry> getLineWork(const geom::Geometry& geom);
/// Extracts linework for polygonal components.
//
/// @param g the geometry from which to extract
/// @return a lineal geometry containing the extracted linework
- std::auto_ptr<geom::Geometry> extractLineWork(const geom::Geometry& geom);
+ std::unique_ptr<geom::Geometry> extractLineWork(const geom::Geometry& geom);
// Declare type as noncopyable
FuzzyPointLocator(const FuzzyPointLocator& other);
diff --git a/include/geos/operation/overlay/validate/OffsetPointGenerator.h b/include/geos/operation/overlay/validate/OffsetPointGenerator.h
index 16ba6a4..3b1bbf9 100644
--- a/include/geos/operation/overlay/validate/OffsetPointGenerator.h
+++ b/include/geos/operation/overlay/validate/OffsetPointGenerator.h
@@ -21,12 +21,12 @@
#include <geos/export.h>
#include <geos/algorithm/PointLocator.h> // for composition
-#include <geos/geom/Geometry.h> // for auto_ptr visibility of dtor
-#include <geos/geom/MultiPoint.h> // for auto_ptr visibility of dtor
+#include <geos/geom/Geometry.h> // for unique_ptr visibility of dtor
+#include <geos/geom/MultiPoint.h> // for unique_ptr visibility of dtor
#include <geos/geom/Coordinate.h> // for use in vector
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -57,7 +57,7 @@ public:
OffsetPointGenerator(const geom::Geometry& geom, double offset);
/// Gets the computed offset points.
- std::auto_ptr< std::vector<geom::Coordinate> > getPoints();
+ std::unique_ptr< std::vector<geom::Coordinate> > getPoints();
private:
@@ -65,7 +65,7 @@ private:
double offsetDistance;
- std::auto_ptr< std::vector<geom::Coordinate> > offsetPts;
+ std::unique_ptr< std::vector<geom::Coordinate> > offsetPts;
void extractPoints(const geom::LineString* line);
diff --git a/include/geos/operation/relate/RelateComputer.h b/include/geos/operation/relate/RelateComputer.h
index 23268e0..02a7515 100644
--- a/include/geos/operation/relate/RelateComputer.h
+++ b/include/geos/operation/relate/RelateComputer.h
@@ -90,7 +90,7 @@ private:
geomgraph::NodeMap nodes;
/// this intersection matrix will hold the results compute for the relate
- std::auto_ptr<geom::IntersectionMatrix> im;
+ std::unique_ptr<geom::IntersectionMatrix> im;
std::vector<geomgraph::Edge*> isolatedEdges;
diff --git a/include/geos/operation/union/CascadedPolygonUnion.h b/include/geos/operation/union/CascadedPolygonUnion.h
index 925d5c7..2cecfbc 100644
--- a/include/geos/operation/union/CascadedPolygonUnion.h
+++ b/include/geos/operation/union/CascadedPolygonUnion.h
@@ -97,7 +97,7 @@ private:
* @param g the geometry to filter
* @return a Polygonal geometry
*/
- static std::auto_ptr<geom::Geometry> restrictToPolygons(std::auto_ptr<geom::Geometry> g);
+ static std::unique_ptr<geom::Geometry> restrictToPolygons(std::unique_ptr<geom::Geometry> g);
public:
CascadedPolygonUnion();
diff --git a/include/geos/operation/union/PointGeometryUnion.h b/include/geos/operation/union/PointGeometryUnion.h
index 67b3b75..31bbec3 100644
--- a/include/geos/operation/union/PointGeometryUnion.h
+++ b/include/geos/operation/union/PointGeometryUnion.h
@@ -48,7 +48,7 @@ class GEOS_DLL PointGeometryUnion
{
public:
- static std::auto_ptr<geom::Geometry> Union(
+ static std::unique_ptr<geom::Geometry> Union(
const geom::Puntal& pointGeom,
const geom::Geometry& otherGeom);
@@ -56,7 +56,7 @@ public:
PointGeometryUnion(const geom::Puntal& pointGeom,
const geom::Geometry& otherGeom);
- std::auto_ptr<geom::Geometry> Union() const;
+ std::unique_ptr<geom::Geometry> Union() const;
private:
const geom::Geometry& pointGeom;
diff --git a/include/geos/operation/union/UnaryUnionOp.h b/include/geos/operation/union/UnaryUnionOp.h
index 14daec3..5fcc0cf 100644
--- a/include/geos/operation/union/UnaryUnionOp.h
+++ b/include/geos/operation/union/UnaryUnionOp.h
@@ -87,21 +87,21 @@ class GEOS_DLL UnaryUnionOp
public:
template <typename T>
- static std::auto_ptr<geom::Geometry> Union(const T& geoms)
+ static std::unique_ptr<geom::Geometry> Union(const T& geoms)
{
UnaryUnionOp op(geoms);
return op.Union();
}
template <class T>
- static std::auto_ptr<geom::Geometry> Union(const T& geoms,
+ static std::unique_ptr<geom::Geometry> Union(const T& geoms,
geom::GeometryFactory& geomFact)
{
UnaryUnionOp op(geoms, geomFact);
return op.Union();
}
- static std::auto_ptr<geom::Geometry> Union(const geom::Geometry& geom)
+ static std::unique_ptr<geom::Geometry> Union(const geom::Geometry& geom)
{
UnaryUnionOp op(geom);
return op.Union();
@@ -140,7 +140,7 @@ public:
* @return an empty GEOMETRYCOLLECTION if no geometries were provided
* in the input
*/
- std::auto_ptr<geom::Geometry> Union();
+ std::unique_ptr<geom::Geometry> Union();
private:
@@ -181,7 +181,7 @@ private:
* @param g0 a geometry
* @return the union of the input geometry
*/
- std::auto_ptr<geom::Geometry> unionNoOpt(const geom::Geometry& g0)
+ std::unique_ptr<geom::Geometry> unionNoOpt(const geom::Geometry& g0)
{
using geos::operation::overlay::OverlayOp;
//using geos::operation::overlay::snap::SnapIfNeededOverlayOp;
@@ -202,8 +202,8 @@ private:
* @return the union of the input(s)
* @return null if both inputs are null
*/
- std::auto_ptr<geom::Geometry> unionWithNull(std::auto_ptr<geom::Geometry> g0,
- std::auto_ptr<geom::Geometry> g1);
+ std::unique_ptr<geom::Geometry> unionWithNull(std::unique_ptr<geom::Geometry> g0,
+ std::unique_ptr<geom::Geometry> g1);
std::vector<const geom::Polygon*> polygons;
std::vector<const geom::LineString*> lines;
@@ -211,7 +211,7 @@ private:
const geom::GeometryFactory* geomFact;
- std::auto_ptr<geom::Geometry> empty;
+ std::unique_ptr<geom::Geometry> empty;
};
diff --git a/include/geos/operation/valid/ConnectedInteriorTester.h b/include/geos/operation/valid/ConnectedInteriorTester.h
index 8ac51fe..16c0b5d 100644
--- a/include/geos/operation/valid/ConnectedInteriorTester.h
+++ b/include/geos/operation/valid/ConnectedInteriorTester.h
@@ -23,7 +23,7 @@
#include <geos/export.h>
#include <geos/geom/Coordinate.h> // for composition
-#include <geos/geom/GeometryFactory.h> // for GeometryFactory::unique_ptr
+#include <geos/geom/GeometryFactory.h> // for GeometryFactory::Ptr
#include <vector>
@@ -84,7 +84,7 @@ protected:
private:
- geom::GeometryFactory::unique_ptr geometryFactory;
+ geom::GeometryFactory::Ptr geometryFactory;
geomgraph::GeometryGraph &geomGraph;
diff --git a/include/geos/precision/CommonBitsOp.h b/include/geos/precision/CommonBitsOp.h
index 4b05e4b..af16b8a 100644
--- a/include/geos/precision/CommonBitsOp.h
+++ b/include/geos/precision/CommonBitsOp.h
@@ -16,7 +16,7 @@
#define GEOS_PRECISION_COMMONBITSOP_H
#include <geos/export.h>
-#include <geos/precision/CommonBitsRemover.h> // for auto_ptr composition
+#include <geos/precision/CommonBitsRemover.h> // for unique_ptr composition
#include <vector>
#include <memory>
@@ -53,7 +53,7 @@ private:
bool returnToOriginalPrecision;
- std::auto_ptr<CommonBitsRemover> cbr;
+ std::unique_ptr<CommonBitsRemover> cbr;
/** \brief
* Computes a copy of the input Geometry with the calculated
@@ -71,8 +71,8 @@ private:
void removeCommonBits(
const geom::Geometry* geom0,
const geom::Geometry* geom1,
- std::auto_ptr<geom::Geometry>& rgeom0,
- std::auto_ptr<geom::Geometry>& rgeom1);
+ std::unique_ptr<geom::Geometry>& rgeom0,
+ std::unique_ptr<geom::Geometry>& rgeom1);
public:
diff --git a/include/geos/precision/GeometryPrecisionReducer.h b/include/geos/precision/GeometryPrecisionReducer.h
index 336c165..40069b1 100644
--- a/include/geos/precision/GeometryPrecisionReducer.h
+++ b/include/geos/precision/GeometryPrecisionReducer.h
@@ -20,8 +20,8 @@
#define GEOS_PRECISION_GEOMETRYPRECISIONREDUCER_H
#include <geos/export.h>
-#include <geos/geom/GeometryFactory.h> // for GeometryFactory::unique_ptr
-#include <memory> // for auto_ptr
+#include <geos/geom/GeometryFactory.h> // for GeometryFactory::Ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -53,12 +53,12 @@ private:
bool isPointwise;
- std::auto_ptr<geom::Geometry> reducePointwise( const geom::Geometry& geom );
+ std::unique_ptr<geom::Geometry> reducePointwise( const geom::Geometry& geom );
- std::auto_ptr<geom::Geometry> fixPolygonalTopology(
+ std::unique_ptr<geom::Geometry> fixPolygonalTopology(
const geom::Geometry& geom );
- geom::GeometryFactory::unique_ptr createFactory(
+ geom::GeometryFactory::Ptr createFactory(
const geom::GeometryFactory& oldGF,
const geom::PrecisionModel& newPM );
@@ -78,7 +78,7 @@ public:
* @param precModel the precision model to use
* @return the reduced geometry
*/
- static std::auto_ptr<geom::Geometry> reduce(
+ static std::unique_ptr<geom::Geometry> reduce(
const geom::Geometry &g,
const geom::PrecisionModel &precModel )
{
@@ -97,7 +97,7 @@ public:
* @param precModel the precision model to use
* @return the reduced geometry
*/
- static std::auto_ptr<geom::Geometry> reducePointwise(
+ static std::unique_ptr<geom::Geometry> reducePointwise(
const geom::Geometry &g,
const geom::PrecisionModel &precModel )
{
@@ -153,7 +153,7 @@ public:
isPointwise = pointwise;
}
- std::auto_ptr<geom::Geometry> reduce(const geom::Geometry& geom);
+ std::unique_ptr<geom::Geometry> reduce(const geom::Geometry& geom);
};
diff --git a/include/geos/precision/MinimumClearance.h b/include/geos/precision/MinimumClearance.h
index 5724c18..d33ac9b 100644
--- a/include/geos/precision/MinimumClearance.h
+++ b/include/geos/precision/MinimumClearance.h
@@ -29,7 +29,7 @@ class GEOS_DLL MinimumClearance {
private:
const geom::Geometry* inputGeom;
double minClearance;
- std::auto_ptr<geom::CoordinateSequence> minClearancePts;
+ std::unique_ptr<geom::CoordinateSequence> minClearancePts;
void compute();
public:
@@ -50,7 +50,7 @@ class GEOS_DLL MinimumClearance {
* @return the value of the minimum clearance distance
* or <tt>LINESTRING EMPTY</tt> if no Minimum Clearance distance exists
*/
- std::auto_ptr<geom::LineString> getLine();
+ std::unique_ptr<geom::LineString> getLine();
};
}
}
diff --git a/include/geos/simplify/DouglasPeuckerLineSimplifier.h b/include/geos/simplify/DouglasPeuckerLineSimplifier.h
index 6b223aa..e60f197 100644
--- a/include/geos/simplify/DouglasPeuckerLineSimplifier.h
+++ b/include/geos/simplify/DouglasPeuckerLineSimplifier.h
@@ -21,7 +21,7 @@
#include <geos/export.h>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -47,15 +47,15 @@ class GEOS_DLL DouglasPeuckerLineSimplifier {
public:
typedef std::vector<short int> BoolVect;
- typedef std::auto_ptr<BoolVect> BoolVectAutoPtr;
+ typedef std::unique_ptr<BoolVect> BoolVectAutoPtr;
typedef std::vector<geom::Coordinate> CoordsVect;
- typedef std::auto_ptr<CoordsVect> CoordsVectAutoPtr;
+ typedef std::unique_ptr<CoordsVect> CoordsVectAutoPtr;
/** \brief
* Returns a newly allocated Coordinate vector, wrapped
- * into an auto_ptr
+ * into an unique_ptr
*/
static CoordsVectAutoPtr simplify(
const CoordsVect& nPts,
@@ -75,7 +75,7 @@ public:
/** \brief
* Returns a newly allocated Coordinate vector, wrapped
- * into an auto_ptr
+ * into an unique_ptr
*/
CoordsVectAutoPtr simplify();
diff --git a/include/geos/simplify/DouglasPeuckerSimplifier.h b/include/geos/simplify/DouglasPeuckerSimplifier.h
index 0bd1a60..d6c80f5 100644
--- a/include/geos/simplify/DouglasPeuckerSimplifier.h
+++ b/include/geos/simplify/DouglasPeuckerSimplifier.h
@@ -20,7 +20,7 @@
#define GEOS_SIMPLIFY_DOUBGLASPEUCKERSIMPLIFIER_H
#include <geos/export.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
@@ -51,7 +51,7 @@ class GEOS_DLL DouglasPeuckerSimplifier {
public:
- static std::auto_ptr<geom::Geometry> simplify(
+ static std::unique_ptr<geom::Geometry> simplify(
const geom::Geometry* geom,
double tolerance);
@@ -69,7 +69,7 @@ public:
*/
void setDistanceTolerance(double tolerance);
- std::auto_ptr<geom::Geometry> getResultGeometry();
+ std::unique_ptr<geom::Geometry> getResultGeometry();
private:
diff --git a/include/geos/simplify/LineSegmentIndex.h b/include/geos/simplify/LineSegmentIndex.h
index b1bc608..fa6ed0e 100644
--- a/include/geos/simplify/LineSegmentIndex.h
+++ b/include/geos/simplify/LineSegmentIndex.h
@@ -25,7 +25,7 @@
#include <geos/export.h>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifdef _MSC_VER
#pragma warning(push)
@@ -65,12 +65,12 @@ public:
void remove(const geom::LineSegment* seg);
- std::auto_ptr< std::vector<geom::LineSegment*> >
+ std::unique_ptr< std::vector<geom::LineSegment*> >
query(const geom::LineSegment* seg) const;
private:
- std::auto_ptr<index::quadtree::Quadtree> index;
+ std::unique_ptr<index::quadtree::Quadtree> index;
std::vector<geom::Envelope*> newEnvelopes;
diff --git a/include/geos/simplify/TaggedLineString.h b/include/geos/simplify/TaggedLineString.h
index 8afc83c..d21a904 100644
--- a/include/geos/simplify/TaggedLineString.h
+++ b/include/geos/simplify/TaggedLineString.h
@@ -63,11 +63,11 @@ public:
typedef std::vector<geom::Coordinate> CoordVect;
- typedef std::auto_ptr<CoordVect> CoordVectPtr;
+ typedef std::unique_ptr<CoordVect> CoordVectPtr;
typedef geom::CoordinateSequence CoordSeq;
- typedef std::auto_ptr<geom::CoordinateSequence> CoordSeqPtr;
+ typedef std::unique_ptr<geom::CoordinateSequence> CoordSeqPtr;
TaggedLineString(const geom::LineString* nParentLine,
std::size_t minimumSize=2);
@@ -92,11 +92,11 @@ public:
const std::vector<TaggedLineSegment*>& getSegments() const;
- void addToResult(std::auto_ptr<TaggedLineSegment> seg);
+ void addToResult(std::unique_ptr<TaggedLineSegment> seg);
- std::auto_ptr<geom::Geometry> asLineString() const;
+ std::unique_ptr<geom::Geometry> asLineString() const;
- std::auto_ptr<geom::Geometry> asLinearRing() const;
+ std::unique_ptr<geom::Geometry> asLinearRing() const;
private:
diff --git a/include/geos/simplify/TaggedLineStringSimplifier.h b/include/geos/simplify/TaggedLineStringSimplifier.h
index e5ff415..034c919 100644
--- a/include/geos/simplify/TaggedLineStringSimplifier.h
+++ b/include/geos/simplify/TaggedLineStringSimplifier.h
@@ -94,7 +94,7 @@ private:
// externally owned
LineSegmentIndex* outputIndex;
- std::auto_ptr<algorithm::LineIntersector> li;
+ std::unique_ptr<algorithm::LineIntersector> li;
/// non-const as segments are possibly added to it
TaggedLineString* line;
@@ -124,7 +124,7 @@ private:
bool hasInteriorIntersection(const geom::LineSegment& seg0,
const geom::LineSegment& seg1) const;
- std::auto_ptr<TaggedLineSegment> flatten(
+ std::unique_ptr<TaggedLineSegment> flatten(
std::size_t start, std::size_t end);
/** \brief
diff --git a/include/geos/simplify/TaggedLinesSimplifier.h b/include/geos/simplify/TaggedLinesSimplifier.h
index 0afce17..11c2ce7 100644
--- a/include/geos/simplify/TaggedLinesSimplifier.h
+++ b/include/geos/simplify/TaggedLinesSimplifier.h
@@ -105,11 +105,11 @@ private:
void simplify(TaggedLineString& line);
- std::auto_ptr<LineSegmentIndex> inputIndex;
+ std::unique_ptr<LineSegmentIndex> inputIndex;
- std::auto_ptr<LineSegmentIndex> outputIndex;
+ std::unique_ptr<LineSegmentIndex> outputIndex;
- std::auto_ptr<TaggedLineStringSimplifier> taggedlineSimplifier;
+ std::unique_ptr<TaggedLineStringSimplifier> taggedlineSimplifier;
};
} // namespace geos::simplify
diff --git a/include/geos/simplify/TopologyPreservingSimplifier.h b/include/geos/simplify/TopologyPreservingSimplifier.h
index 7d4c54e..8c38140 100644
--- a/include/geos/simplify/TopologyPreservingSimplifier.h
+++ b/include/geos/simplify/TopologyPreservingSimplifier.h
@@ -26,7 +26,7 @@
#include <geos/export.h>
#include <geos/geom/Geometry.h>
#include <geos/simplify/TaggedLinesSimplifier.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <map>
#ifdef _MSC_VER
@@ -60,7 +60,7 @@ class GEOS_DLL TopologyPreservingSimplifier
public:
- static std::auto_ptr<geom::Geometry> simplify(
+ static std::unique_ptr<geom::Geometry> simplify(
const geom::Geometry* geom,
double tolerance);
@@ -78,13 +78,13 @@ public:
*/
void setDistanceTolerance(double tolerance);
- std::auto_ptr<geom::Geometry> getResultGeometry();
+ std::unique_ptr<geom::Geometry> getResultGeometry();
private:
const geom::Geometry* inputGeom;
- std::auto_ptr<TaggedLinesSimplifier> lineSimplifier;
+ std::unique_ptr<TaggedLinesSimplifier> lineSimplifier;
};
diff --git a/include/geos/triangulate/DelaunayTriangulationBuilder.h b/include/geos/triangulate/DelaunayTriangulationBuilder.h
index 16c069b..cbc6444 100644
--- a/include/geos/triangulate/DelaunayTriangulationBuilder.h
+++ b/include/geos/triangulate/DelaunayTriangulationBuilder.h
@@ -129,7 +129,7 @@ public:
* @param geomFact the geometry factory to use to create the output
* @return the edges of the triangulation. The caller takes ownership of the returned object.
*/
- std::auto_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory &geomFact);
+ std::unique_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory &geomFact);
/**
* Gets the faces of the computed triangulation as a {@link GeometryCollection}
@@ -138,7 +138,7 @@ public:
* @param geomFact the geometry factory to use to create the output
* @return the faces of the triangulation. The caller takes ownership of the returned object.
*/
- std::auto_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory& geomFact);
/**
* Computes the {@link Envelope} of a collection of {@link Coordinate}s.
diff --git a/include/geos/triangulate/VoronoiDiagramBuilder.h b/include/geos/triangulate/VoronoiDiagramBuilder.h
index aa847f0..dad3761 100644
--- a/include/geos/triangulate/VoronoiDiagramBuilder.h
+++ b/include/geos/triangulate/VoronoiDiagramBuilder.h
@@ -94,7 +94,7 @@ public:
*
* @return the subdivision containing the triangulation
*/
- std::auto_ptr<quadedge::QuadEdgeSubdivision> getSubdivision();
+ std::unique_ptr<quadedge::QuadEdgeSubdivision> getSubdivision();
/**
* Gets the faces of the computed diagram as a {@link GeometryCollection}
@@ -103,7 +103,7 @@ public:
* @param geomFact the geometry factory to use to create the output
* @return the faces of the diagram
*/
- std::auto_ptr<geom::GeometryCollection> getDiagram(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::GeometryCollection> getDiagram(const geom::GeometryFactory& geomFact);
/**
* Gets the faces of the computed diagram as a {@link GeometryCollection}
@@ -112,19 +112,19 @@ public:
* @param geomFact the geometry factory to use to create the output
* @return the faces of the diagram
*/
- std::auto_ptr<geom::Geometry> getDiagramEdges(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::Geometry> getDiagramEdges(const geom::GeometryFactory& geomFact);
private:
- std::auto_ptr<geom::CoordinateSequence> siteCoords;
+ std::unique_ptr<geom::CoordinateSequence> siteCoords;
double tolerance;
- std::auto_ptr<quadedge::QuadEdgeSubdivision> subdiv;
+ std::unique_ptr<quadedge::QuadEdgeSubdivision> subdiv;
const geom::Envelope* clipEnv; // externally owned
geom::Envelope diagramEnv;
void create();
- static std::auto_ptr<geom::GeometryCollection>
+ static std::unique_ptr<geom::GeometryCollection>
clipGeometryCollection(const geom::GeometryCollection& geom, const geom::Envelope& clipEnv);
};
diff --git a/include/geos/triangulate/quadedge/QuadEdge.h b/include/geos/triangulate/quadedge/QuadEdge.h
index 367b32d..c005f81 100644
--- a/include/geos/triangulate/quadedge/QuadEdge.h
+++ b/include/geos/triangulate/quadedge/QuadEdge.h
@@ -60,7 +60,7 @@ public:
* @return the new QuadEdge* The caller is reponsible for
* freeing the returned pointer
*/
- static std::auto_ptr<QuadEdge> makeEdge(const Vertex &o, const Vertex &d);
+ static std::unique_ptr<QuadEdge> makeEdge(const Vertex &o, const Vertex &d);
/**
* Creates a new QuadEdge connecting the destination of a to the origin of
@@ -71,7 +71,7 @@ public:
* @return the new QuadEdge* The caller is reponsible for
* freeing the returned pointer
*/
- static std::auto_ptr<QuadEdge> connect(QuadEdge &a, QuadEdge &b);
+ static std::unique_ptr<QuadEdge> connect(QuadEdge &a, QuadEdge &b);
/**
* Splices two edges together or apart.
@@ -351,7 +351,7 @@ public:
*
* @return a LineSegment
*/
- std::auto_ptr<geom::LineSegment> toLineSegment() const;
+ std::unique_ptr<geom::LineSegment> toLineSegment() const;
};
} //namespace geos.triangulate.quadedge
diff --git a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
index 4a839ac..c738ac7 100644
--- a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
+++ b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
@@ -100,7 +100,7 @@ private:
double edgeCoincidenceTolerance;
Vertex frameVertex[3];
geom::Envelope frameEnv;
- std::auto_ptr<QuadEdgeLocator> locator;
+ std::unique_ptr<QuadEdgeLocator> locator;
public:
/**
@@ -159,8 +159,8 @@ public:
* @param locator
* a QuadEdgeLocator
*/
- inline void setLocator(std::auto_ptr<QuadEdgeLocator> locator) {
- this->locator = locator;
+ inline void setLocator(std::unique_ptr<QuadEdgeLocator> locator) {
+ this->locator = std::move(locator);
}
/**
@@ -331,7 +331,7 @@ public:
* @return a List of QuadEdges. The caller takes ownership of the returned QuadEdgeList but not the
* items it contains.
*/
- std::auto_ptr<QuadEdgeList> getPrimaryEdges(bool includeFrame);
+ std::unique_ptr<QuadEdgeList> getPrimaryEdges(bool includeFrame);
/*****************************************************************************
* Visitors
@@ -386,7 +386,7 @@ public:
* @param geomFact the GeometryFactory to use
* @return a MultiLineString. The caller takes ownership of the returned object.
*/
- std::auto_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory& geomFact);
/**
* Gets the geometry for the triangles in a triangulated subdivision as a {@link GeometryCollection}
@@ -395,7 +395,7 @@ public:
* @param geomFact the GeometryFactory to use
* @return a GeometryCollection of triangular Polygons. The caller takes ownership of the returned object.
*/
- std::auto_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory &geomFact);
+ std::unique_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory &geomFact);
/**
* Gets the cells in the Voronoi diagram for this triangulation.
@@ -407,7 +407,7 @@ public:
* @param geomFact a geometry factory
* @return a GeometryCollection of Polygons
*/
- std::auto_ptr<geom::GeometryCollection> getVoronoiDiagram(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::GeometryCollection> getVoronoiDiagram(const geom::GeometryFactory& geomFact);
/**
* Gets the cells in the Voronoi diagram for this triangulation.
@@ -419,7 +419,7 @@ public:
* @param geomFact a geometry factory
* @return a MultiLineString
*/
- std::auto_ptr<geom::MultiLineString> getVoronoiDiagramEdges(const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::MultiLineString> getVoronoiDiagramEdges(const geom::GeometryFactory& geomFact);
/**
* Gets a List of {@link Polygon}s for the Voronoi cells
@@ -431,7 +431,7 @@ public:
* @param geomFact a geometry factory
* @return a List of Polygons
*/
- std::auto_ptr< std::vector<geom::Geometry*> > getVoronoiCellPolygons(const geom::GeometryFactory& geomFact);
+ std::unique_ptr< std::vector<geom::Geometry*> > getVoronoiCellPolygons(const geom::GeometryFactory& geomFact);
/**
* Gets a List of {@link LineString}s for the Voronoi cells
@@ -443,7 +443,7 @@ public:
* @param geomFact a geometry factory
* @return a List of LineString
*/
- std::auto_ptr< std::vector<geom::Geometry*> > getVoronoiCellEdges(const geom::GeometryFactory& geomFact);
+ std::unique_ptr< std::vector<geom::Geometry*> > getVoronoiCellEdges(const geom::GeometryFactory& geomFact);
/**
* Gets a collection of {@link QuadEdge}s whose origin
@@ -461,7 +461,7 @@ public:
* @param includeFrame true if the frame vertices should be included
* @return a collection of QuadEdge with the vertices of the subdivision as their origins
*/
- std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList> getVertexUniqueEdges(bool includeFrame);
+ std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList> getVertexUniqueEdges(bool includeFrame);
/**
* Gets the Voronoi cell around a site specified
@@ -474,7 +474,7 @@ public:
* @param geomFact a factory for building the polygon
* @return a polygon indicating the cell extent
*/
- std::auto_ptr<geom::Geometry> getVoronoiCellPolygon(QuadEdge* qe ,const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::Geometry> getVoronoiCellPolygon(QuadEdge* qe ,const geom::GeometryFactory& geomFact);
/**
* Gets the Voronoi cell edge around a site specified
@@ -487,7 +487,7 @@ public:
* @param geomFact a factory for building the polygon
* @return a polygon indicating the cell extent
*/
- std::auto_ptr<geom::Geometry> getVoronoiCellEdge(QuadEdge* qe ,const geom::GeometryFactory& geomFact);
+ std::unique_ptr<geom::Geometry> getVoronoiCellEdge(QuadEdge* qe ,const geom::GeometryFactory& geomFact);
};
diff --git a/include/geos/triangulate/quadedge/Vertex.h b/include/geos/triangulate/quadedge/Vertex.h
index d0af7ce..8c5becd 100644
--- a/include/geos/triangulate/quadedge/Vertex.h
+++ b/include/geos/triangulate/quadedge/Vertex.h
@@ -143,18 +143,18 @@ public:
* @param v, a vertex
* @return returns the scaled vector
*/
- inline std::auto_ptr<Vertex> times(double c) const {
- return std::auto_ptr<Vertex>(new Vertex(c * p.x, c * p.y));
+ inline std::unique_ptr<Vertex> times(double c) const {
+ return std::unique_ptr<Vertex>(new Vertex(c * p.x, c * p.y));
}
/* Vector addition */
- inline std::auto_ptr<Vertex> sum(Vertex v) const {
- return std::auto_ptr<Vertex>(new Vertex(p.x + v.getX(), p.y + v.getY()));
+ inline std::unique_ptr<Vertex> sum(Vertex v) const {
+ return std::unique_ptr<Vertex>(new Vertex(p.x + v.getX(), p.y + v.getY()));
}
/* and subtraction */
- inline std::auto_ptr<Vertex> sub(const Vertex &v) const {
- return std::auto_ptr<Vertex>(new Vertex(p.x - v.getX(), p.y - v.getY()));
+ inline std::unique_ptr<Vertex> sub(const Vertex &v) const {
+ return std::unique_ptr<Vertex>(new Vertex(p.x - v.getX(), p.y - v.getY()));
}
/* magnitude of vector */
@@ -163,8 +163,8 @@ public:
}
/* returns k X v (cross product). this is a vector perpendicular to v */
- inline std::auto_ptr<Vertex> cross() const {
- return std::auto_ptr<Vertex>(new Vertex(p.y, -p.x));
+ inline std::unique_ptr<Vertex> cross() const {
+ return std::unique_ptr<Vertex>(new Vertex(p.y, -p.x));
}
/** ************************************************************* */
@@ -203,7 +203,7 @@ public:
bool leftOf(const QuadEdge &e) const;
private:
- static std::auto_ptr<algorithm::HCoordinate> bisector(const Vertex &a, const Vertex &b);
+ static std::unique_ptr<algorithm::HCoordinate> bisector(const Vertex &a, const Vertex &b);
inline double distance(const Vertex &v1, const Vertex &v2)
{
@@ -229,7 +229,7 @@ private:
* @param a the other end point.
* @return the point mid-way between this and that.
*/
- virtual std::auto_ptr<Vertex> midPoint(const Vertex &a);
+ virtual std::unique_ptr<Vertex> midPoint(const Vertex &a);
/**
* Computes the centre of the circumcircle of this vertex and two others.
@@ -238,7 +238,7 @@ private:
* @param c
* @return the Coordinate which is the circumcircle of the 3 points.
*/
- virtual std::auto_ptr<Vertex> circleCenter(const Vertex &b, const Vertex &c) const;
+ virtual std::unique_ptr<Vertex> circleCenter(const Vertex &b, const Vertex &c) const;
/**
* For this vertex enclosed in a triangle defined by three verticies v0, v1 and v2, interpolate
diff --git a/include/geos/util/GeometricShapeFactory.h b/include/geos/util/GeometricShapeFactory.h
index 8d34012..4bc2d3f 100644
--- a/include/geos/util/GeometricShapeFactory.h
+++ b/include/geos/util/GeometricShapeFactory.h
@@ -59,7 +59,7 @@ namespace util { // geos::util
* gsf.setSize(100);
* gsf.setNumPoints(100);
* gsf.setBase(Coordinate(0, 0));
- * std::auto_ptr<Polygon> rect ( gsf.createRectangle() );
+ * std::unique_ptr<Polygon> rect ( gsf.createRectangle() );
* </pre>
*
*/
diff --git a/src/algorithm/InteriorPointArea.cpp b/src/algorithm/InteriorPointArea.cpp
index 787c2a2..3a1f6d1 100644
--- a/src/algorithm/InteriorPointArea.cpp
+++ b/src/algorithm/InteriorPointArea.cpp
@@ -30,7 +30,7 @@
#include <vector>
#include <typeinfo>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
using namespace std;
using namespace geos::geom;
@@ -167,13 +167,13 @@ InteriorPointArea::addPolygon(const Geometry *geometry)
Coordinate intPt;
double width;
- auto_ptr<LineString> bisector ( horizontalBisector(geometry) );
+ unique_ptr<LineString> bisector ( horizontalBisector(geometry) );
if ( bisector->getLength() == 0.0 ) {
width = 0;
intPt = bisector->getCoordinateN(0);
}
else {
- auto_ptr<Geometry> intersections ( bisector->intersection(geometry) );
+ unique_ptr<Geometry> intersections ( bisector->intersection(geometry) );
const Geometry *widestIntersection = widestGeometry(intersections.get());
const Envelope *env = widestIntersection->getEnvelopeInternal();
width=env->getWidth();
diff --git a/src/geom/Geometry.cpp b/src/geom/Geometry.cpp
index 81abf7c..efe4388 100644
--- a/src/geom/Geometry.cpp
+++ b/src/geom/Geometry.cpp
@@ -108,7 +108,7 @@ Geometry::GeometryChangedFilter Geometry::geometryChangedFilter;
Geometry::Geometry(const GeometryFactory *newFactory)
:
- envelope(NULL),
+ envelope(nullptr),
_factory(newFactory),
_userData(NULL)
{
@@ -288,7 +288,7 @@ Geometry::disjoint(const Geometry *g) const
if (! getEnvelopeInternal()->intersects(g->getEnvelopeInternal()))
return true;
#endif
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isDisjoint();
return res;
}
@@ -301,7 +301,7 @@ Geometry::touches(const Geometry *g) const
if (! getEnvelopeInternal()->intersects(g->getEnvelopeInternal()))
return false;
#endif
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isTouches(getDimension(), g->getDimension());
return res;
}
@@ -341,7 +341,7 @@ Geometry::intersects(const Geometry *g) const
return predicate::RectangleIntersects::intersects(*p, *this);
}
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isIntersects();
return res;
}
@@ -363,7 +363,7 @@ Geometry::covers(const Geometry* g) const
return true;
}
- auto_ptr<IntersectionMatrix> im(relate(g));
+ unique_ptr<IntersectionMatrix> im(relate(g));
return im->isCovers();
}
@@ -376,7 +376,7 @@ Geometry::crosses(const Geometry *g) const
if (! getEnvelopeInternal()->intersects(g->getEnvelopeInternal()))
return false;
#endif
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isCrosses(getDimension(), g->getDimension());
return res;
}
@@ -406,7 +406,7 @@ Geometry::contains(const Geometry *g) const
// return predicate::RectangleContains::contains((const Polygon&)*g, *this);
//}
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isContains();
return res;
}
@@ -419,7 +419,7 @@ Geometry::overlaps(const Geometry *g) const
if (! getEnvelopeInternal()->intersects(g->getEnvelopeInternal()))
return false;
#endif
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isOverlaps(getDimension(), g->getDimension());
return res;
}
@@ -427,7 +427,7 @@ Geometry::overlaps(const Geometry *g) const
bool
Geometry::relate(const Geometry *g, const string &intersectionPattern) const
{
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->matches(intersectionPattern);
return res;
}
@@ -444,7 +444,7 @@ Geometry::equals(const Geometry *g) const
if (isEmpty()) return g->isEmpty();
else if (g->isEmpty()) return isEmpty();
- auto_ptr<IntersectionMatrix> im ( relate(g) );
+ unique_ptr<IntersectionMatrix> im ( relate(g) );
bool res=im->isEquals(getDimension(), g->getDimension());
return res;
}
@@ -587,7 +587,7 @@ Geometry::Union(const Geometry *other) const
}
/* public */
-Geometry::AutoPtr
+Geometry::Ptr
Geometry::Union() const
{
using geos::operation::geounion::UnaryUnionOp;
diff --git a/src/geom/GeometryCollection.cpp b/src/geom/GeometryCollection.cpp
index 4ae343a..ecbfd4d 100644
--- a/src/geom/GeometryCollection.cpp
+++ b/src/geom/GeometryCollection.cpp
@@ -249,10 +249,10 @@ GeometryCollection::normalize()
sort(geometries->begin(), geometries->end(), GeometryGreaterThen());
}
-Envelope::AutoPtr
+Envelope::Ptr
GeometryCollection::computeEnvelopeInternal() const
{
- Envelope::AutoPtr envelope(new Envelope());
+ Envelope::Ptr envelope(new Envelope());
for (size_t i=0; i<geometries->size(); i++) {
const Envelope *env=(*geometries)[i]->getEnvelopeInternal();
envelope->expandToInclude(env);
@@ -270,7 +270,7 @@ GeometryCollection::compareToSameClass(const Geometry *g) const
const Coordinate*
GeometryCollection::getCoordinate() const
{
- // should use auto_ptr here or return NULL or throw an exception !
+ // should use unique_ptr here or return NULL or throw an exception !
// --strk;
if (isEmpty()) return new Coordinate();
return (*geometries)[0]->getCoordinate();
diff --git a/src/geom/GeometryFactory.cpp b/src/geom/GeometryFactory.cpp
index 94ed7d4..d8c306b 100644
--- a/src/geom/GeometryFactory.cpp
+++ b/src/geom/GeometryFactory.cpp
@@ -93,8 +93,8 @@ GeometryFactory::GeometryFactory()
}
/*public static*/
-GeometryFactory::unique_ptr
-GeometryFactory::create() { return GeometryFactory::unique_ptr(new GeometryFactory()); }
+GeometryFactory::Ptr
+GeometryFactory::create() { return GeometryFactory::Ptr(new GeometryFactory()); }
/*protected*/
GeometryFactory::GeometryFactory(const PrecisionModel* pm, int newSRID,
@@ -120,11 +120,11 @@ GeometryFactory::GeometryFactory(const PrecisionModel* pm, int newSRID,
}
/*public static*/
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryFactory::create(const PrecisionModel* pm, int newSRID,
CoordinateSequenceFactory* nCoordinateSequenceFactory)
{
- return GeometryFactory::unique_ptr(
+ return GeometryFactory::Ptr(
new GeometryFactory(pm, newSRID, nCoordinateSequenceFactory)
);
}
@@ -148,11 +148,11 @@ GeometryFactory::GeometryFactory(
}
/*public static*/
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryFactory::create(
CoordinateSequenceFactory* nCoordinateSequenceFactory)
{
- return GeometryFactory::unique_ptr(
+ return GeometryFactory::Ptr(
new GeometryFactory(nCoordinateSequenceFactory)
);
}
@@ -175,10 +175,10 @@ GeometryFactory::GeometryFactory(const PrecisionModel *pm)
}
/*public static*/
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryFactory::create(const PrecisionModel *pm)
{
- return GeometryFactory::unique_ptr(
+ return GeometryFactory::Ptr(
new GeometryFactory(pm)
);
}
@@ -201,10 +201,10 @@ GeometryFactory::GeometryFactory(const PrecisionModel* pm, int newSRID)
}
/*public static*/
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryFactory::create(const PrecisionModel* pm, int newSRID)
{
- return GeometryFactory::unique_ptr(
+ return GeometryFactory::Ptr(
new GeometryFactory(pm, newSRID)
);
}
@@ -221,10 +221,10 @@ GeometryFactory::GeometryFactory(const GeometryFactory &gf)
}
/*public static*/
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryFactory::create(const GeometryFactory &gf)
{
- return GeometryFactory::unique_ptr(
+ return GeometryFactory::Ptr(
new GeometryFactory(gf)
);
}
@@ -470,10 +470,10 @@ GeometryFactory::createLinearRing(CoordinateSequence* newCoords) const
}
/*public*/
-Geometry::AutoPtr
-GeometryFactory::createLinearRing(CoordinateSequence::AutoPtr newCoords) const
+Geometry::Ptr
+GeometryFactory::createLinearRing(CoordinateSequence::Ptr newCoords) const
{
- return Geometry::AutoPtr(new LinearRing(newCoords, this));
+ return Geometry::Ptr(new LinearRing(std::move(newCoords), this));
}
/*public*/
@@ -615,10 +615,10 @@ GeometryFactory::createLineString() const
}
/*public*/
-std::auto_ptr<LineString>
+std::unique_ptr<LineString>
GeometryFactory::createLineString(const LineString& ls) const
{
- return std::auto_ptr<LineString>(new LineString(ls));
+ return std::unique_ptr<LineString>(new LineString(ls));
}
/*public*/
@@ -630,11 +630,11 @@ GeometryFactory::createLineString(CoordinateSequence *newCoords)
}
/*public*/
-Geometry::AutoPtr
-GeometryFactory::createLineString(CoordinateSequence::AutoPtr newCoords)
+Geometry::Ptr
+GeometryFactory::createLineString(CoordinateSequence::Ptr newCoords)
const
{
- return Geometry::AutoPtr(new LineString(newCoords, this));
+ return Geometry::Ptr(new LineString(std::move(newCoords), this));
}
/*public*/
diff --git a/src/geom/LineSegment.cpp b/src/geom/LineSegment.cpp
index 6aaa5bb..96f0fed 100644
--- a/src/geom/LineSegment.cpp
+++ b/src/geom/LineSegment.cpp
@@ -303,13 +303,13 @@ LineSegment::pointAlongOffset(double segmentLengthFraction,
}
/* public */
-std::auto_ptr<LineString>
+std::unique_ptr<LineString>
LineSegment::toGeometry(const GeometryFactory& gf) const
{
CoordinateSequence *cl=new CoordinateArraySequence();
cl->add(p0);
cl->add(p1);
- return std::auto_ptr<LineString>(
+ return std::unique_ptr<LineString>(
gf.createLineString(cl) // ownership transferred
);
}
diff --git a/src/geom/LineString.cpp b/src/geom/LineString.cpp
index eb35180..c0cf23b 100644
--- a/src/geom/LineString.cpp
+++ b/src/geom/LineString.cpp
@@ -92,11 +92,11 @@ LineString::LineString(CoordinateSequence *newCoords,
}
/*public*/
-LineString::LineString(CoordinateSequence::AutoPtr newCoords,
+LineString::LineString(CoordinateSequence::Ptr newCoords,
const GeometryFactory *factory)
:
Geometry(factory),
- points(newCoords)
+ points(std::move(newCoords))
{
validateConstruction();
}
@@ -246,7 +246,7 @@ LineString::isCoordinate(Coordinate& pt) const
}
/*protected*/
-Envelope::AutoPtr
+Envelope::Ptr
LineString::computeEnvelopeInternal() const
{
if (isEmpty()) {
@@ -254,7 +254,7 @@ LineString::computeEnvelopeInternal() const
// as it would indicate "unknown"
// envelope. In this case we
// *know* the envelope is EMPTY.
- return Envelope::AutoPtr(new Envelope());
+ return Envelope::Ptr(new Envelope());
}
assert(points.get());
@@ -275,7 +275,7 @@ LineString::computeEnvelopeInternal() const
// caller expects a newly allocated Envelope.
// this function won't be called twice, unless
// cached Envelope is invalidated (set to NULL)
- return Envelope::AutoPtr(new Envelope(minx, maxx, miny, maxy));
+ return Envelope::Ptr(new Envelope(minx, maxx, miny, maxy));
}
bool
diff --git a/src/geom/LinearRing.cpp b/src/geom/LinearRing.cpp
index 7c2d915..3d4b496 100644
--- a/src/geom/LinearRing.cpp
+++ b/src/geom/LinearRing.cpp
@@ -47,11 +47,11 @@ LinearRing::LinearRing(CoordinateSequence* newCoords,
}
/*public*/
-LinearRing::LinearRing(CoordinateSequence::AutoPtr newCoords,
+LinearRing::LinearRing(CoordinateSequence::Ptr newCoords,
const GeometryFactory *newFactory)
:
Geometry(newFactory),
- LineString(newCoords, newFactory)
+ LineString(std::move(newCoords), newFactory)
{
validateConstruction();
}
diff --git a/src/geom/Point.cpp b/src/geom/Point.cpp
index fb317f9..116a77d 100644
--- a/src/geom/Point.cpp
+++ b/src/geom/Point.cpp
@@ -144,14 +144,14 @@ Point::getBoundary() const
return getFactory()->createGeometryCollection(NULL);
}
-Envelope::AutoPtr
+Envelope::Ptr
Point::computeEnvelopeInternal() const
{
if (isEmpty()) {
- return Envelope::AutoPtr(new Envelope());
+ return Envelope::Ptr(new Envelope());
}
- return Envelope::AutoPtr(new Envelope(getCoordinate()->x,
+ return Envelope::Ptr(new Envelope(getCoordinate()->x,
getCoordinate()->x, getCoordinate()->y,
getCoordinate()->y));
}
diff --git a/src/geom/Polygon.cpp b/src/geom/Polygon.cpp
index 123f2cd..92cce89 100644
--- a/src/geom/Polygon.cpp
+++ b/src/geom/Polygon.cpp
@@ -242,10 +242,10 @@ Polygon::getBoundary() const
return ret;
}
-Envelope::AutoPtr
+Envelope::Ptr
Polygon::computeEnvelopeInternal() const
{
- return Envelope::AutoPtr(new Envelope(*(shell->getEnvelopeInternal())));
+ return Envelope::Ptr(new Envelope(*(shell->getEnvelopeInternal())));
}
bool
diff --git a/src/geom/util/GeometryTransformer.cpp b/src/geom/util/GeometryTransformer.cpp
index 821da72..fddd1f1 100644
--- a/src/geom/util/GeometryTransformer.cpp
+++ b/src/geom/util/GeometryTransformer.cpp
@@ -1,4 +1,4 @@
-/**********************************************************************
+/**********************************************************************
*
* GEOS - Geometry Engine Open Source
* http://geos.osgeo.org
@@ -73,7 +73,7 @@ void GeometryTransformer::setSkipTransformedInvalidInteriorRings(bool b)
}
/*public*/
-auto_ptr<Geometry>
+unique_ptr<Geometry>
GeometryTransformer::transform(const Geometry* nInputGeom)
{
using geos::util::IllegalArgumentException;
@@ -105,17 +105,17 @@ GeometryTransformer::transform(const Geometry* nInputGeom)
throw IllegalArgumentException("Unknown Geometry subtype.");
}
-std::auto_ptr<CoordinateSequence>
+std::unique_ptr<CoordinateSequence>
GeometryTransformer::createCoordinateSequence(
- std::auto_ptr< std::vector<Coordinate> > coords)
+ std::unique_ptr< std::vector<Coordinate> > coords)
{
- return std::auto_ptr<CoordinateSequence>(
+ return std::unique_ptr<CoordinateSequence>(
factory->getCoordinateSequenceFactory()->create(
coords.release())
);
}
-std::auto_ptr<CoordinateSequence>
+std::unique_ptr<CoordinateSequence>
GeometryTransformer::transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent)
@@ -126,10 +126,10 @@ GeometryTransformer::transformCoordinates(
std::cerr << "GeometryTransformer::transformCoordinates(CoordinateSequence " << coords <<", Geometry " << parent << ");" << std::endl;
#endif
- return std::auto_ptr<CoordinateSequence>(coords->clone());
+ return std::unique_ptr<CoordinateSequence>(coords->clone());
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformPoint(
const Point* geom,
const Geometry* parent)
@@ -140,13 +140,13 @@ GeometryTransformer::transformPoint(
std::cerr << "GeometryTransformer::transformPoint(Point " << geom <<", Geometry " << parent << ");" << std::endl;
#endif
- CoordinateSequence::AutoPtr cs(transformCoordinates(
+ CoordinateSequence::Ptr cs(transformCoordinates(
geom->getCoordinatesRO(), geom));
- return Geometry::AutoPtr(factory->createPoint(cs.release()));
+ return Geometry::Ptr(factory->createPoint(cs.release()));
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformMultiPoint(
const MultiPoint* geom,
const Geometry* parent)
@@ -164,7 +164,7 @@ GeometryTransformer::transformMultiPoint(
const Point* p = dynamic_cast<const Point*>(geom->getGeometryN(i));
assert(p);
- Geometry::AutoPtr transformGeom = transformPoint(p, geom);
+ Geometry::Ptr transformGeom = transformPoint(p, geom);
if ( transformGeom.get() == NULL ) continue;
if ( transformGeom->isEmpty() ) continue;
@@ -172,11 +172,11 @@ GeometryTransformer::transformMultiPoint(
transGeomList->push_back(transformGeom.release());
}
- return Geometry::AutoPtr(factory->buildGeometry(transGeomList));
+ return Geometry::Ptr(factory->buildGeometry(transGeomList));
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformLinearRing(
const LinearRing* geom,
const Geometry* parent)
@@ -187,7 +187,7 @@ GeometryTransformer::transformLinearRing(
std::cerr << "GeometryTransformer::transformLinearRing(LinearRing " << geom <<", Geometry " << parent << ");" << std::endl;
#endif
- CoordinateSequence::AutoPtr seq(transformCoordinates(
+ CoordinateSequence::Ptr seq(transformCoordinates(
geom->getCoordinatesRO(), geom));
unsigned int seqSize = seq->size();
@@ -195,14 +195,15 @@ GeometryTransformer::transformLinearRing(
// ensure a valid LinearRing
if ( seqSize > 0 && seqSize < 4 && ! preserveType )
{
- return factory->createLineString(seq);
+ return factory->createLineString(std::move(seq));
+ }
+ else
+ {
+ return factory->createLinearRing(std::move(seq));
}
-
- return factory->createLinearRing(seq);
-
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformLineString(
const LineString* geom,
const Geometry* parent)
@@ -218,7 +219,7 @@ GeometryTransformer::transformLineString(
transformCoordinates(geom->getCoordinatesRO(), geom));
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformMultiLineString(
const MultiLineString* geom,
const Geometry* parent)
@@ -237,7 +238,7 @@ GeometryTransformer::transformMultiLineString(
geom->getGeometryN(i));
assert(l);
- Geometry::AutoPtr transformGeom = transformLineString(l, geom);
+ Geometry::Ptr transformGeom = transformLineString(l, geom);
if ( transformGeom.get() == NULL ) continue;
if ( transformGeom->isEmpty() ) continue;
@@ -245,11 +246,11 @@ GeometryTransformer::transformMultiLineString(
transGeomList->push_back(transformGeom.release());
}
- return Geometry::AutoPtr(factory->buildGeometry(transGeomList));
+ return Geometry::Ptr(factory->buildGeometry(transGeomList));
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformPolygon(
const Polygon* geom,
const Geometry* parent)
@@ -266,7 +267,7 @@ GeometryTransformer::transformPolygon(
geom->getExteriorRing());
assert(lr);
- Geometry::AutoPtr shell = transformLinearRing(lr, geom);
+ Geometry::Ptr shell = transformLinearRing(lr, geom);
if ( shell.get() == NULL
|| ! dynamic_cast<LinearRing*>(shell.get())
|| shell->isEmpty() )
@@ -281,7 +282,7 @@ GeometryTransformer::transformPolygon(
geom->getInteriorRingN(i));
assert(lr);
- Geometry::AutoPtr hole(transformLinearRing(lr, geom));
+ Geometry::Ptr hole(transformLinearRing(lr, geom));
if ( hole.get() == NULL || hole->isEmpty() ) {
continue;
@@ -302,7 +303,7 @@ GeometryTransformer::transformPolygon(
Geometry* sh = shell.release();
LinearRing* lr = dynamic_cast<LinearRing*>(sh);
assert(lr);
- return Geometry::AutoPtr(factory->createPolygon(lr, holes));
+ return Geometry::Ptr(factory->createPolygon(lr, holes));
}
else
{
@@ -317,12 +318,12 @@ GeometryTransformer::transformPolygon(
delete holes; // :(
- return Geometry::AutoPtr(factory->buildGeometry(components));
+ return Geometry::Ptr(factory->buildGeometry(components));
}
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformMultiPolygon(
const MultiPolygon* geom,
const Geometry* parent)
@@ -333,7 +334,7 @@ GeometryTransformer::transformMultiPolygon(
std::cerr << "GeometryTransformer::transformMultiPolygon(MultiPolygon " << geom <<", Geometry " << parent << ");" << std::endl;
#endif
- auto_ptr< vector<Geometry*> > transGeomList( new vector<Geometry*>() );
+ unique_ptr< vector<Geometry*> > transGeomList( new vector<Geometry*>() );
for (std::size_t i=0, n=geom->getNumGeometries(); i<n; i++)
{
@@ -341,7 +342,7 @@ GeometryTransformer::transformMultiPolygon(
geom->getGeometryN(i));
assert(p);
- Geometry::AutoPtr transformGeom = transformPolygon(p, geom);
+ Geometry::Ptr transformGeom = transformPolygon(p, geom);
if ( transformGeom.get() == NULL ) continue;
if ( transformGeom->isEmpty() ) continue;
@@ -349,11 +350,11 @@ GeometryTransformer::transformMultiPolygon(
transGeomList->push_back(transformGeom.release());
}
- return Geometry::AutoPtr(factory->buildGeometry(transGeomList.release()));
+ return Geometry::Ptr(factory->buildGeometry(transGeomList.release()));
}
-Geometry::AutoPtr
+Geometry::Ptr
GeometryTransformer::transformGeometryCollection(
const GeometryCollection* geom,
const Geometry* parent)
@@ -368,7 +369,7 @@ GeometryTransformer::transformGeometryCollection(
for (std::size_t i=0, n=geom->getNumGeometries(); i<n; i++)
{
- Geometry::AutoPtr transformGeom = transform(
+ Geometry::Ptr transformGeom = transform(
geom->getGeometryN(i)); // no parent ?
if ( transformGeom.get() == NULL ) continue;
if ( pruneEmptyGeometry && transformGeom->isEmpty() ) continue;
@@ -379,12 +380,12 @@ GeometryTransformer::transformGeometryCollection(
if ( preserveGeometryCollectionType )
{
- return Geometry::AutoPtr(factory->createGeometryCollection(
+ return Geometry::Ptr(factory->createGeometryCollection(
transGeomList));
}
else
{
- return Geometry::AutoPtr(factory->buildGeometry(transGeomList));
+ return Geometry::Ptr(factory->buildGeometry(transGeomList));
}
}
diff --git a/src/geom/util/SineStarFactory.cpp b/src/geom/util/SineStarFactory.cpp
index aed6941..2086a63 100644
--- a/src/geom/util/SineStarFactory.cpp
+++ b/src/geom/util/SineStarFactory.cpp
@@ -41,10 +41,10 @@ namespace geom { // geos::geom
namespace util { // geos::geom::util
/* public */
-auto_ptr<Polygon>
+unique_ptr<Polygon>
SineStarFactory::createSineStar() const
{
- auto_ptr<Envelope> env ( dim.getEnvelope() );
+ unique_ptr<Envelope> env ( dim.getEnvelope() );
double radius = env->getWidth() / 2.0;
double armRatio = armLengthRatio;
@@ -57,7 +57,7 @@ SineStarFactory::createSineStar() const
double centreX = env->getMinX() + radius;
double centreY = env->getMinY() + radius;
- auto_ptr< vector<Coordinate> > pts ( new vector<Coordinate>(nPts+1) );
+ unique_ptr< vector<Coordinate> > pts ( new vector<Coordinate>(nPts+1) );
int iPt = 0;
for (int i = 0; i < nPts; i++) {
// the fraction of the way thru the current arm - in [0,1]
@@ -81,11 +81,11 @@ SineStarFactory::createSineStar() const
}
(*pts)[iPt] = Coordinate((*pts)[0]);
- auto_ptr<CoordinateSequence> cs (
+ unique_ptr<CoordinateSequence> cs (
geomFact->getCoordinateSequenceFactory()->create( pts.release() )
);
- auto_ptr<LinearRing> ring ( geomFact->createLinearRing( cs.release() ) );
- auto_ptr<Polygon> poly ( geomFact->createPolygon(ring.release(), 0) );
+ unique_ptr<LinearRing> ring ( geomFact->createLinearRing( cs.release() ) );
+ unique_ptr<Polygon> poly ( geomFact->createPolygon(ring.release(), 0) );
return poly;
}
diff --git a/src/geomgraph/GeometryGraph.cpp b/src/geomgraph/GeometryGraph.cpp
index 967d792..53d4bbf 100644
--- a/src/geomgraph/GeometryGraph.cpp
+++ b/src/geomgraph/GeometryGraph.cpp
@@ -50,7 +50,7 @@
#include <geos/inline.h>
#include <vector>
-#include <memory> // auto_ptr
+#include <memory> // unique_ptr
#include <cassert>
#include <typeinfo>
@@ -372,7 +372,7 @@ GeometryGraph::computeSelfNodes(LineIntersector &li,
{
SegmentIntersector *si = new SegmentIntersector(&li, true, false);
si->setIsDoneIfProperInt(isDoneIfProperInt);
- auto_ptr<EdgeSetIntersector> esi(createEdgeSetIntersector());
+ unique_ptr<EdgeSetIntersector> esi(createEdgeSetIntersector());
typedef vector<Edge*> EC;
EC *se = edges;
@@ -410,7 +410,7 @@ GeometryGraph::computeEdgeIntersections(GeometryGraph *g,
SegmentIntersector *si=new SegmentIntersector(li, includeProper, true);
si->setBoundaryNodes(getBoundaryNodes(), g->getBoundaryNodes());
- auto_ptr<EdgeSetIntersector> esi(createEdgeSetIntersector());
+ unique_ptr<EdgeSetIntersector> esi(createEdgeSetIntersector());
typedef vector<Edge*> EC;
diff --git a/src/geomgraph/PlanarGraph.cpp b/src/geomgraph/PlanarGraph.cpp
index e7b6a68..a1db6e5 100644
--- a/src/geomgraph/PlanarGraph.cpp
+++ b/src/geomgraph/PlanarGraph.cpp
@@ -212,8 +212,8 @@ PlanarGraph::addEdges(const vector<Edge*>& edgesToAdd)
// PlanarGraph destructor will delete all DirectedEdges
// in edgeEndList, which is where these are added
// by the ::add(EdgeEnd) call
- std::auto_ptr<DirectedEdge> de1(new DirectedEdge(e, true));
- std::auto_ptr<DirectedEdge> de2(new DirectedEdge(e, false));
+ std::unique_ptr<DirectedEdge> de1(new DirectedEdge(e, true));
+ std::unique_ptr<DirectedEdge> de2(new DirectedEdge(e, false));
de1->setSym(de2.get());
de2->setSym(de1.get());
diff --git a/src/index/chain/MonotoneChain.cpp b/src/index/chain/MonotoneChain.cpp
index fc5df41..9396bc3 100644
--- a/src/index/chain/MonotoneChain.cpp
+++ b/src/index/chain/MonotoneChain.cpp
@@ -66,10 +66,10 @@ MonotoneChain::getLineSegment(size_t index, LineSegment& ls) const
ls.p1 = pts[index+1];
}
-std::auto_ptr<CoordinateSequence>
+std::unique_ptr<CoordinateSequence>
MonotoneChain::getCoordinates() const
{
- return std::auto_ptr<CoordinateSequence>(pts.clone());
+ return std::unique_ptr<CoordinateSequence>(pts.clone());
}
void
diff --git a/src/index/quadtree/Node.cpp b/src/index/quadtree/Node.cpp
index aea9390..1499203 100644
--- a/src/index/quadtree/Node.cpp
+++ b/src/index/quadtree/Node.cpp
@@ -41,21 +41,20 @@ namespace index { // geos.index
namespace quadtree { // geos.index.quadtree
/* public static */
-std::auto_ptr<Node>
+std::unique_ptr<Node>
Node::createNode(const Envelope& env)
{
Key key(env);
-
- std::auto_ptr<Envelope> nenv ( new Envelope(key.getEnvelope()) );
- std::auto_ptr<Node> node (
- new Node(nenv, key.getLevel())
+ std::unique_ptr<Envelope> envelope(new Envelope(key.getEnvelope()));
+ std::unique_ptr<Node> node (
+ new Node(std::move(envelope), key.getLevel())
);
- return node;
+ return std::move(node);
}
/* static public */
-std::auto_ptr<Node>
-Node::createExpanded(std::auto_ptr<Node> node, const Envelope& addEnv)
+std::unique_ptr<Node>
+Node::createExpanded(std::unique_ptr<Node> node, const Envelope& addEnv)
{
Envelope expandEnv(addEnv);
if ( node.get() ) // should this be asserted ?
@@ -67,10 +66,10 @@ Node::createExpanded(std::auto_ptr<Node> node, const Envelope& addEnv)
cerr<<"Node::createExpanded computed "<<expandEnv.toString()<<endl;
#endif
- std::auto_ptr<Node> largerNode = createNode(expandEnv);
+ std::unique_ptr<Node> largerNode = createNode(expandEnv);
if ( node.get() ) // should this be asserted ?
{
- largerNode->insertNode(node);
+ largerNode->insertNode(std::move(node));
}
return largerNode;
@@ -112,7 +111,7 @@ Node::find(const Envelope *searchEnv)
}
void
-Node::insertNode(std::auto_ptr<Node> node)
+Node::insertNode(std::unique_ptr<Node> node)
{
assert( env->contains(node->getEnvelope()) );
@@ -131,10 +130,10 @@ Node::insertNode(std::auto_ptr<Node> node)
{
// the quad is not a direct child, so make a new child
// quad to contain it and recursively insert the quad
- std::auto_ptr<Node> childNode ( createSubnode(index) );
+ std::unique_ptr<Node> childNode ( createSubnode(index) );
// childNode takes ownership of node
- childNode->insertNode(node);
+ childNode->insertNode(std::move(node));
// We take ownership of childNode
delete subnode[index];
@@ -153,7 +152,7 @@ Node::getSubnode(int index)
return subnode[index];
}
-std::auto_ptr<Node>
+std::unique_ptr<Node>
Node::createSubnode(int index)
{
// create a new subquad in the appropriate quadrant
@@ -188,8 +187,8 @@ Node::createSubnode(int index)
maxy=env->getMaxY();
break;
}
- std::auto_ptr<Envelope> sqEnv ( new Envelope(minx,maxx,miny,maxy) );
- std::auto_ptr<Node> node ( new Node(sqEnv, level-1) );
+ std::unique_ptr<Envelope> sqEnv ( new Envelope(minx,maxx,miny,maxy) );
+ std::unique_ptr<Node> node ( new Node(std::move(sqEnv), level-1) );
return node;
}
diff --git a/src/index/quadtree/Root.cpp b/src/index/quadtree/Root.cpp
index a7274ae..27a2424 100644
--- a/src/index/quadtree/Root.cpp
+++ b/src/index/quadtree/Root.cpp
@@ -78,11 +78,11 @@ Root::insert(const Envelope *itemEnv, void* item)
*/
if (node==NULL || !node->getEnvelope()->contains(itemEnv))
{
- std::auto_ptr<Node> snode (node); // may be NULL
+ std::unique_ptr<Node> snode (node); // may be NULL
node = 0; subnode[index] = 0;
- std::auto_ptr<Node> largerNode =
- Node::createExpanded(snode, *itemEnv);
+ std::unique_ptr<Node> largerNode =
+ Node::createExpanded(std::move(snode), *itemEnv);
#if GEOS_DEBUG
std::cerr<<"("<<this<<") created expanded node " << largerNode.get() << " containing previously reported subnode" << std::endl;
diff --git a/src/index/strtree/AbstractSTRtree.cpp b/src/index/strtree/AbstractSTRtree.cpp
index 914017e..fd2f926 100644
--- a/src/index/strtree/AbstractSTRtree.cpp
+++ b/src/index/strtree/AbstractSTRtree.cpp
@@ -63,15 +63,15 @@ AbstractSTRtree::build()
}
/*protected*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
AbstractSTRtree::createParentBoundables(BoundableList* childBoundables,
int newLevel)
{
assert(!childBoundables->empty());
- std::auto_ptr< BoundableList > parentBoundables ( new BoundableList() );
+ std::unique_ptr< BoundableList > parentBoundables ( new BoundableList() );
parentBoundables->push_back(createNode(newLevel));
- std::auto_ptr< BoundableList > sortedChildBoundables ( sortBoundables(childBoundables) );
+ std::unique_ptr< BoundableList > sortedChildBoundables ( sortBoundables(childBoundables) );
for (BoundableList::iterator i=sortedChildBoundables->begin(),
e=sortedChildBoundables->end();
@@ -96,7 +96,7 @@ AbstractNode*
AbstractSTRtree::createHigherLevels(BoundableList* boundablesOfALevel, int level)
{
assert(!boundablesOfALevel->empty());
- std::auto_ptr< BoundableList > parentBoundables (
+ std::unique_ptr< BoundableList > parentBoundables (
createParentBoundables(boundablesOfALevel,level+1)
);
@@ -304,10 +304,10 @@ AbstractSTRtree::iterate(ItemVisitor& visitor)
}
/*protected*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
AbstractSTRtree::boundablesAtLevel(int level)
{
- std::auto_ptr<BoundableList> boundables ( new BoundableList() );
+ std::unique_ptr<BoundableList> boundables ( new BoundableList() );
boundablesAtLevel(level, root, boundables.get());
return boundables;
}
@@ -351,7 +351,7 @@ AbstractSTRtree::boundablesAtLevel(int level, AbstractNode* top,
ItemsList* AbstractSTRtree::itemsTree(AbstractNode* node)
{
- std::auto_ptr<ItemsList> valuesTreeForNode (new ItemsList());
+ std::unique_ptr<ItemsList> valuesTreeForNode (new ItemsList());
BoundableList::iterator end = node->getChildBoundables()->end();
for (BoundableList::iterator i = node->getChildBoundables()->begin();
diff --git a/src/index/strtree/BoundablePair.cpp b/src/index/strtree/BoundablePair.cpp
index 0e2ac8d..36b6262 100644
--- a/src/index/strtree/BoundablePair.cpp
+++ b/src/index/strtree/BoundablePair.cpp
@@ -104,7 +104,7 @@ void BoundablePair::expand(const Boundable* bndComposite, const Boundable* bndOt
std::vector<Boundable*> *children = ((AbstractNode*) bndComposite)->getChildBoundables();
for(std::vector<Boundable*>::iterator it = children->begin(); it != children->end(); ++it) {
Boundable* child = *it;
- std::auto_ptr<BoundablePair> bp(new BoundablePair(child, bndOther, itemDistance));
+ std::unique_ptr<BoundablePair> bp(new BoundablePair(child, bndOther, itemDistance));
if (minDistance == std::numeric_limits<double>::infinity() || bp->getDistance() < minDistance) {
priQ.push(bp.release());
}
diff --git a/src/index/strtree/SIRtree.cpp b/src/index/strtree/SIRtree.cpp
index 996983f..001ca21 100644
--- a/src/index/strtree/SIRtree.cpp
+++ b/src/index/strtree/SIRtree.cpp
@@ -33,14 +33,14 @@ static bool compareSIRBoundables(Boundable *a, Boundable *b){
}
/*protected*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
SIRtree::createParentBoundables(BoundableList *childBoundables,int newLevel)
{
assert(!childBoundables->empty());
- std::auto_ptr<BoundableList> parentBoundables ( new BoundableList() );
+ std::unique_ptr<BoundableList> parentBoundables ( new BoundableList() );
parentBoundables->push_back(createNode(newLevel));
- std::auto_ptr<BoundableList> sortedChildBoundables ( sortBoundables(childBoundables) );
+ std::unique_ptr<BoundableList> sortedChildBoundables ( sortBoundables(childBoundables) );
//for(unsigned int i=0;i<sortedChildBoundables->size();i++)
for (BoundableList::iterator i=sortedChildBoundables->begin(),
@@ -131,10 +131,10 @@ void SIRtree::insert(double x1, double x2,void* item) {
AbstractSTRtree::insert(new Interval(min(x1,x2),max(x1, x2)),item);
}
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
SIRtree::sortBoundables(const BoundableList* input)
{
- std::auto_ptr<BoundableList> output ( new BoundableList(*input) );
+ std::unique_ptr<BoundableList> output ( new BoundableList(*input) );
sort(output->begin(), output->end(), compareSIRBoundables);
//output->sort(compareSIRBoundables);
return output;
diff --git a/src/index/strtree/STRtree.cpp b/src/index/strtree/STRtree.cpp
index 0d70434..9bc8435 100644
--- a/src/index/strtree/STRtree.cpp
+++ b/src/index/strtree/STRtree.cpp
@@ -106,19 +106,19 @@ STRtree::STRIntersectsOp::intersects(const void* aBounds, const void* bBounds)
}
/*private*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
STRtree::createParentBoundables(BoundableList* childBoundables, int newLevel)
{
assert(!childBoundables->empty());
int minLeafCount=(int) ceil((double)childBoundables->size()/(double)getNodeCapacity());
- std::auto_ptr<BoundableList> sortedChildBoundables ( sortBoundables(childBoundables) );
+ std::unique_ptr<BoundableList> sortedChildBoundables ( sortBoundables(childBoundables) );
- std::auto_ptr< vector<BoundableList*> > verticalSlicesV (
+ std::unique_ptr< vector<BoundableList*> > verticalSlicesV (
verticalSlices(sortedChildBoundables.get(), (int)ceil(sqrt((double)minLeafCount)))
);
- std::auto_ptr<BoundableList> ret (
+ std::unique_ptr<BoundableList> ret (
createParentBoundablesFromVerticalSlices(verticalSlicesV.get(), newLevel)
);
for (size_t i=0, vssize=verticalSlicesV->size(); i<vssize; ++i)
@@ -131,15 +131,15 @@ STRtree::createParentBoundables(BoundableList* childBoundables, int newLevel)
}
/*private*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
STRtree::createParentBoundablesFromVerticalSlices(std::vector<BoundableList*>* verticalSlices, int newLevel)
{
assert(!verticalSlices->empty());
- std::auto_ptr<BoundableList> parentBoundables( new BoundableList() );
+ std::unique_ptr<BoundableList> parentBoundables( new BoundableList() );
for (size_t i=0, vssize=verticalSlices->size(); i<vssize; ++i)
{
- std::auto_ptr<BoundableList> toAdd (
+ std::unique_ptr<BoundableList> toAdd (
createParentBoundablesFromVerticalSlice(
(*verticalSlices)[i], newLevel)
);
@@ -154,7 +154,7 @@ STRtree::createParentBoundablesFromVerticalSlices(std::vector<BoundableList*>* v
}
/*protected*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
STRtree::createParentBoundablesFromVerticalSlice(BoundableList* childBoundables, int newLevel)
{
return AbstractSTRtree::createParentBoundables(childBoundables, newLevel);
@@ -328,11 +328,11 @@ STRtree::insert(const Envelope *itemEnv, void* item)
}
/*private*/
-std::auto_ptr<BoundableList>
+std::unique_ptr<BoundableList>
STRtree::sortBoundables(const BoundableList* input)
{
assert(input);
- std::auto_ptr<BoundableList> output ( new BoundableList(*input) );
+ std::unique_ptr<BoundableList> output ( new BoundableList(*input) );
assert(output->size() == input->size());
sort(output->begin(), output->end(), yComparator);
diff --git a/src/io/WKTReader.cpp b/src/io/WKTReader.cpp
index b1b885e..25e24dc 100644
--- a/src/io/WKTReader.cpp
+++ b/src/io/WKTReader.cpp
@@ -60,7 +60,7 @@ namespace io { // geos.io
Geometry *
WKTReader::read(const string &wellKnownText)
{
- //auto_ptr<StringTokenizer> tokenizer(new StringTokenizer(wellKnownText));
+ //unique_ptr<StringTokenizer> tokenizer(new StringTokenizer(wellKnownText));
CLocalizer clocale;
StringTokenizer tokenizer(wellKnownText);
Geometry *g=NULL;
diff --git a/src/linearref/LinearLocation.cpp b/src/linearref/LinearLocation.cpp
index 49de76f..0b8b147 100644
--- a/src/linearref/LinearLocation.cpp
+++ b/src/linearref/LinearLocation.cpp
@@ -202,7 +202,7 @@ LinearLocation::getCoordinate(const Geometry* linearGeom) const
}
/* public */
-std::auto_ptr<LineSegment>
+std::unique_ptr<LineSegment>
LinearLocation::getSegment(const Geometry* linearGeom) const
{
const LineString* lineComp = dynamic_cast<const LineString *> (linearGeom->getGeometryN(componentIndex));
@@ -211,10 +211,10 @@ LinearLocation::getSegment(const Geometry* linearGeom) const
if (segmentIndex >= lineComp->getNumPoints() - 1)
{
Coordinate prev = lineComp->getCoordinateN(lineComp->getNumPoints() - 2);
- return std::auto_ptr<LineSegment>(new LineSegment(prev, p0));
+ return std::unique_ptr<LineSegment>(new LineSegment(prev, p0));
}
Coordinate p1 = lineComp->getCoordinateN(segmentIndex + 1);
- return std::auto_ptr<LineSegment>(new LineSegment(p0, p1));
+ return std::unique_ptr<LineSegment>(new LineSegment(p0, p1));
}
/* public */
diff --git a/src/noding/GeometryNoder.cpp b/src/noding/GeometryNoder.cpp
index 86eae67..fe2ad05 100644
--- a/src/noding/GeometryNoder.cpp
+++ b/src/noding/GeometryNoder.cpp
@@ -36,7 +36,7 @@
#include <geos/noding/snapround/SimpleSnapRounder.h>
#include <geos/noding/snapround/MCIndexSnapRounder.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <iostream>
namespace geos {
@@ -73,7 +73,7 @@ private:
/* public static */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
GeometryNoder::node(const geom::Geometry& geom)
{
GeometryNoder noder(geom);
@@ -88,7 +88,7 @@ GeometryNoder::GeometryNoder(const geom::Geometry& g)
}
/* private */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
GeometryNoder::toGeometry(SegmentString::NonConstVect& nodedEdges)
{
const geom::GeometryFactory *geomFact = argGeom.getFactory();
@@ -112,13 +112,13 @@ GeometryNoder::toGeometry(SegmentString::NonConstVect& nodedEdges)
}
}
- std::auto_ptr<geom::Geometry> noded ( geomFact->createMultiLineString( lines ) );
+ std::unique_ptr<geom::Geometry> noded ( geomFact->createMultiLineString( lines ) );
return noded;
}
/* public */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
GeometryNoder::getNoded()
{
SegmentString::NonConstVect lineList;
@@ -138,7 +138,7 @@ GeometryNoder::getNoded()
throw ex;
}
- std::auto_ptr<geom::Geometry> noded = toGeometry(*nodedEdges);
+ std::unique_ptr<geom::Geometry> noded = toGeometry(*nodedEdges);
for ( unsigned int i = 0, n = nodedEdges->size(); i < n; ++i )
delete ( *nodedEdges )[i];
diff --git a/src/noding/snapround/HotPixel.cpp b/src/noding/snapround/HotPixel.cpp
index e35b9e3..6c9c178 100644
--- a/src/noding/snapround/HotPixel.cpp
+++ b/src/noding/snapround/HotPixel.cpp
@@ -60,7 +60,7 @@ HotPixel::getSafeEnvelope() const
if (safeEnv.get() == NULL) {
double safeTolerance = SAFE_ENV_EXPANSION_FACTOR / scaleFactor;
- safeEnv = auto_ptr<Envelope>(new Envelope(originalPt.x - safeTolerance,
+ safeEnv = unique_ptr<Envelope>(new Envelope(originalPt.x - safeTolerance,
originalPt.x + safeTolerance,
originalPt.y - safeTolerance,
originalPt.y + safeTolerance
diff --git a/src/noding/snapround/MCIndexSnapRounder.cpp b/src/noding/snapround/MCIndexSnapRounder.cpp
index e04b0bb..277e98e 100644
--- a/src/noding/snapround/MCIndexSnapRounder.cpp
+++ b/src/noding/snapround/MCIndexSnapRounder.cpp
@@ -126,7 +126,7 @@ void
MCIndexSnapRounder::checkCorrectness(
SegmentString::NonConstVect& inputSegmentStrings)
{
- auto_ptr<SegmentString::NonConstVect> resultSegStrings(
+ unique_ptr<SegmentString::NonConstVect> resultSegStrings(
NodedSegmentString::getNodedSubstrings(inputSegmentStrings)
);
diff --git a/src/operation/IsSimpleOp.cpp b/src/operation/IsSimpleOp.cpp
index 864f5c4..e832106 100644
--- a/src/operation/IsSimpleOp.cpp
+++ b/src/operation/IsSimpleOp.cpp
@@ -171,7 +171,7 @@ IsSimpleOp::isSimpleLinearGeometry(const Geometry *geom)
if (geom->isEmpty()) return true;
GeometryGraph graph(0,geom);
LineIntersector li;
- std::auto_ptr<SegmentIntersector> si (graph.computeSelfNodes(&li,true));
+ std::unique_ptr<SegmentIntersector> si (graph.computeSelfNodes(&li,true));
// if no self-intersection, must be simple
if (!si->hasIntersection()) return true;
diff --git a/src/operation/buffer/BufferBuilder.cpp b/src/operation/buffer/BufferBuilder.cpp
index ac0608b..b9881be 100644
--- a/src/operation/buffer/BufferBuilder.cpp
+++ b/src/operation/buffer/BufferBuilder.cpp
@@ -81,7 +81,7 @@ namespace {
// Debug routine
template <class Iterator>
-std::auto_ptr<Geometry>
+std::unique_ptr<Geometry>
convertSegStrings(const GeometryFactory* fact, Iterator it, Iterator et)
{
std::vector<Geometry*> lines;
@@ -91,7 +91,7 @@ convertSegStrings(const GeometryFactory* fact, Iterator it, Iterator et)
lines.push_back(line);
++it;
}
- return std::auto_ptr<Geometry>(fact->buildGeometry(lines));
+ return std::unique_ptr<Geometry>(fact->buildGeometry(lines));
}
}
@@ -151,7 +151,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
BufferParameters modParams = bufParams;
modParams.setEndCapStyle(BufferParameters::CAP_FLAT);
modParams.setSingleSided(false); // ignore parameter for areal-only geometries
- std::auto_ptr<Geometry> buf;
+ std::unique_ptr<Geometry> buf;
// This is a (temp?) hack to workaround the fact that
// BufferBuilder BufferParamaters are immutable after
@@ -163,7 +163,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
}
// Create MultiLineStrings from this polygon.
- std::auto_ptr<Geometry> bufLineString ( buf->getBoundary() );
+ std::unique_ptr<Geometry> bufLineString ( buf->getBoundary() );
#ifdef GEOS_DEBUG_SSB
std::cerr << "input|" << *l << std::endl;
@@ -175,7 +175,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
std::vector< CoordinateSequence* > lineList;
{
- std::auto_ptr< CoordinateSequence > coords(g->getCoordinates());
+ std::unique_ptr< CoordinateSequence > coords(g->getCoordinates());
curveBuilder.getSingleSidedLineCurve(coords.get(), distance,
lineList, leftSide, !leftSide);
coords.reset();
@@ -221,7 +221,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
for (size_t i=0, n=curveList.size(); i<n; ++i) delete curveList[i];
curveList.clear();
- std::auto_ptr<Geometry> singleSided ( geomFact->createMultiLineString(
+ std::unique_ptr<Geometry> singleSided ( geomFact->createMultiLineString(
singleSidedNodedEdges ) );
#ifdef GEOS_DEBUG_SSB
@@ -235,7 +235,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
// diverge from original offset curves due to the addition of
// intersections with caps and joins curves
using geos::operation::overlay::snap::SnapOverlayOp;
- std::auto_ptr<Geometry> intersectedLines = SnapOverlayOp::overlayOp(*singleSided, *bufLineString, OverlayOp::opINTERSECTION);
+ std::unique_ptr<Geometry> intersectedLines = SnapOverlayOp::overlayOp(*singleSided, *bufLineString, OverlayOp::opINTERSECTION);
#ifdef GEOS_DEBUG_SSB
std::cerr << "intersection" << "|" << *intersectedLines << std::endl;
@@ -244,7 +244,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
// Merge result lines together.
LineMerger lineMerge;
lineMerge.add( intersectedLines.get() );
- std::auto_ptr< std::vector< LineString* > > mergedLines (
+ std::unique_ptr< std::vector< LineString* > > mergedLines (
lineMerge.getMergedLineStrings() );
// Convert the result into a std::vector< Geometry* >.
@@ -255,7 +255,7 @@ BufferBuilder::bufferLineSingleSided( const Geometry* g, double distance,
{
// Remove end points if they are a part of the original line to be
// buffered.
- CoordinateSequence::AutoPtr coords(mergedLines->back()->getCoordinates());
+ CoordinateSequence::Ptr coords(mergedLines->back()->getCoordinates());
if ( NULL != coords.get() )
{
// Use 98% of the buffer width as the point-distance requirement - this
@@ -411,7 +411,7 @@ BufferBuilder::buffer(const Geometry *g, double distance)
#endif
Geometry* resultGeom=NULL;
- std::auto_ptr< std::vector<Geometry*> > resultPolyList;
+ std::unique_ptr< std::vector<Geometry*> > resultPolyList;
std::vector<BufferSubgraph*> subgraphList;
try {
diff --git a/src/operation/buffer/BufferInputLineSimplifier.cpp b/src/operation/buffer/BufferInputLineSimplifier.cpp
index ca9d78c..bc56c29 100644
--- a/src/operation/buffer/BufferInputLineSimplifier.cpp
+++ b/src/operation/buffer/BufferInputLineSimplifier.cpp
@@ -43,7 +43,7 @@ BufferInputLineSimplifier::BufferInputLineSimplifier(
{}
/*public static*/
-std::auto_ptr<geom::CoordinateSequence>
+std::unique_ptr<geom::CoordinateSequence>
BufferInputLineSimplifier::simplify(const geom::CoordinateSequence& inputLine,
double distanceTol)
{
@@ -52,7 +52,7 @@ BufferInputLineSimplifier::simplify(const geom::CoordinateSequence& inputLine,
}
/* public */
-std::auto_ptr<geom::CoordinateSequence>
+std::unique_ptr<geom::CoordinateSequence>
BufferInputLineSimplifier::simplify(double nDistanceTol)
{
distanceTol = fabs(nDistanceTol);
@@ -120,10 +120,10 @@ BufferInputLineSimplifier::findNextNonDeletedIndex(unsigned int index) const
}
/* private */
-std::auto_ptr<geom::CoordinateSequence>
+std::unique_ptr<geom::CoordinateSequence>
BufferInputLineSimplifier::collapseLine() const
{
- std::auto_ptr<geom::CoordinateSequence> coordList(
+ std::unique_ptr<geom::CoordinateSequence> coordList(
new CoordinateArraySequence());
for (size_t i=0, n=inputLine.size(); i<n; ++i)
diff --git a/src/operation/buffer/BufferOp.cpp b/src/operation/buffer/BufferOp.cpp
index 10e47c1..eb12dce 100644
--- a/src/operation/buffer/BufferOp.cpp
+++ b/src/operation/buffer/BufferOp.cpp
@@ -254,7 +254,7 @@ BufferOp::bufferFixedPrecision(const PrecisionModel& fixedPM)
//
const Geometry *workGeom = argGeom;
const PrecisionModel& argPM = *(argGeom->getFactory()->getPrecisionModel());
- std::auto_ptr<Geometry> fixedGeom;
+ std::unique_ptr<Geometry> fixedGeom;
if ( argPM.getType() != PrecisionModel::FIXED || argPM.getScale() != fixedPM.getScale() )
{
using precision::GeometryPrecisionReducer;
diff --git a/src/operation/buffer/OffsetCurveBuilder.cpp b/src/operation/buffer/OffsetCurveBuilder.cpp
index fa79ad9..e3d1b8d 100644
--- a/src/operation/buffer/OffsetCurveBuilder.cpp
+++ b/src/operation/buffer/OffsetCurveBuilder.cpp
@@ -67,7 +67,7 @@ OffsetCurveBuilder::getLineCurve(const CoordinateSequence *inputPts,
double posDistance = std::abs(distance);
- std::auto_ptr<OffsetSegmentGenerator> segGen = getSegGen(posDistance);
+ std::unique_ptr<OffsetSegmentGenerator> segGen = getSegGen(posDistance);
if (inputPts->getSize() <= 1) {
computePointCurve(inputPts->getAt(0), *segGen);
} else {
@@ -118,12 +118,12 @@ OffsetCurveBuilder::getSingleSidedLineCurve(const CoordinateSequence* inputPts,
double distTol = simplifyTolerance(distance);
- std::auto_ptr<OffsetSegmentGenerator> segGen = getSegGen(distance);
+ std::unique_ptr<OffsetSegmentGenerator> segGen = getSegGen(distance);
if ( leftSide ) {
//--------- compute points for left side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp1_ =
+ std::unique_ptr<CoordinateSequence> simp1_ =
BufferInputLineSimplifier::simplify( *inputPts, distTol );
const CoordinateSequence& simp1 = *simp1_;
@@ -143,7 +143,7 @@ OffsetCurveBuilder::getSingleSidedLineCurve(const CoordinateSequence* inputPts,
//---------- compute points for right side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp2_ =
+ std::unique_ptr<CoordinateSequence> simp2_ =
BufferInputLineSimplifier::simplify( *inputPts, -distTol );
const CoordinateSequence& simp2 = *simp2_;
@@ -181,7 +181,7 @@ OffsetCurveBuilder::getRingCurve(const CoordinateSequence *inputPts,
return;
}
- std::auto_ptr<OffsetSegmentGenerator> segGen = getSegGen(std::abs(distance));
+ std::unique_ptr<OffsetSegmentGenerator> segGen = getSegGen(std::abs(distance));
computeRingBufferCurve(*inputPts, side, *segGen);
segGen->getCoordinates(lineList);
}
@@ -202,7 +202,7 @@ OffsetCurveBuilder::computeLineBufferCurve(const CoordinateSequence& inputPts,
//--------- compute points for left side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp1_ =
+ std::unique_ptr<CoordinateSequence> simp1_ =
BufferInputLineSimplifier::simplify(inputPts, distTol);
const CoordinateSequence& simp1 = *simp1_;
@@ -218,7 +218,7 @@ OffsetCurveBuilder::computeLineBufferCurve(const CoordinateSequence& inputPts,
//---------- compute points for right side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp2_ =
+ std::unique_ptr<CoordinateSequence> simp2_ =
BufferInputLineSimplifier::simplify(inputPts, -distTol);
const CoordinateSequence& simp2 = *simp2_;
@@ -244,7 +244,7 @@ OffsetCurveBuilder::computeRingBufferCurve(const CoordinateSequence& inputPts,
// ensure that correct side is simplified
if (side == Position::RIGHT)
distTol = -distTol;
- std::auto_ptr<CoordinateSequence> simp_ =
+ std::unique_ptr<CoordinateSequence> simp_ =
BufferInputLineSimplifier::simplify(inputPts, distTol);
const CoordinateSequence& simp = *simp_;
@@ -272,7 +272,7 @@ OffsetCurveBuilder::computeSingleSidedBufferCurve(
//---------- compute points for right side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp2_ =
+ std::unique_ptr<CoordinateSequence> simp2_ =
BufferInputLineSimplifier::simplify(inputPts, -distTol);
const CoordinateSequence& simp2 = *simp2_;
@@ -290,7 +290,7 @@ OffsetCurveBuilder::computeSingleSidedBufferCurve(
//--------- compute points for left side of line
// Simplify the appropriate side of the line before generating
- std::auto_ptr<CoordinateSequence> simp1_ =
+ std::unique_ptr<CoordinateSequence> simp1_ =
BufferInputLineSimplifier::simplify(inputPts, distTol);
const CoordinateSequence& simp1 = *simp1_;
@@ -307,10 +307,10 @@ OffsetCurveBuilder::computeSingleSidedBufferCurve(
}
/*private*/
-std::auto_ptr<OffsetSegmentGenerator>
+std::unique_ptr<OffsetSegmentGenerator>
OffsetCurveBuilder::getSegGen(double dist)
{
- std::auto_ptr<OffsetSegmentGenerator> osg(
+ std::unique_ptr<OffsetSegmentGenerator> osg(
new OffsetSegmentGenerator(precisionModel, bufParams, dist)
);
return osg;
diff --git a/src/operation/buffer/OffsetCurveSetBuilder.cpp b/src/operation/buffer/OffsetCurveSetBuilder.cpp
index 59a995e..b32b0b6 100644
--- a/src/operation/buffer/OffsetCurveSetBuilder.cpp
+++ b/src/operation/buffer/OffsetCurveSetBuilder.cpp
@@ -203,7 +203,7 @@ OffsetCurveSetBuilder::addLineString(const LineString *line)
#if GEOS_DEBUG
std::cerr<<__FUNCTION__<<": "<<line->toString()<<std::endl;
#endif
- std::auto_ptr<CoordinateSequence> coord(CoordinateSequence::removeRepeatedPoints(line->getCoordinatesRO()));
+ std::unique_ptr<CoordinateSequence> coord(CoordinateSequence::removeRepeatedPoints(line->getCoordinatesRO()));
#if GEOS_DEBUG
std::cerr<<" After coordinate removal: "<<coord->toString()<<std::endl;
#endif
diff --git a/src/operation/distance/FacetSequenceTreeBuilder.cpp b/src/operation/distance/FacetSequenceTreeBuilder.cpp
index bd5c970..e1273af 100644
--- a/src/operation/distance/FacetSequenceTreeBuilder.cpp
+++ b/src/operation/distance/FacetSequenceTreeBuilder.cpp
@@ -28,8 +28,8 @@ namespace operation {
namespace distance {
STRtree* FacetSequenceTreeBuilder::build(const Geometry* g) {
- std::auto_ptr<STRtree> tree(new STRtree(STR_TREE_NODE_CAPACITY));
- std::auto_ptr<std::vector<FacetSequence*> > sections(computeFacetSequences(g));
+ std::unique_ptr<STRtree> tree(new STRtree(STR_TREE_NODE_CAPACITY));
+ std::unique_ptr<std::vector<FacetSequence*> > sections(computeFacetSequences(g));
for (std::vector<FacetSequence*>::iterator it = sections->begin(); it != sections->end(); ++it) {
FacetSequence* section = *it;
tree->insert(section->getEnvelope(), section);
@@ -40,7 +40,7 @@ STRtree* FacetSequenceTreeBuilder::build(const Geometry* g) {
}
std::vector<FacetSequence*> * FacetSequenceTreeBuilder::computeFacetSequences(const Geometry* g) {
- std::auto_ptr<std::vector<FacetSequence*> > sections(new std::vector<FacetSequence*>());
+ std::unique_ptr<std::vector<FacetSequence*> > sections(new std::vector<FacetSequence*>());
class FacetSequenceAdder;
class FacetSequenceAdder : public geom::GeometryComponentFilter {
diff --git a/src/operation/distance/IndexedFacetDistance.cpp b/src/operation/distance/IndexedFacetDistance.cpp
index ce28061..a8f4d55 100644
--- a/src/operation/distance/IndexedFacetDistance.cpp
+++ b/src/operation/distance/IndexedFacetDistance.cpp
@@ -44,7 +44,7 @@ namespace geos {
}
} itemDistance;
- std::auto_ptr<STRtree> tree2(FacetSequenceTreeBuilder::build(g));
+ std::unique_ptr<STRtree> tree2(FacetSequenceTreeBuilder::build(g));
std::pair<const void*, const void*> obj = cachedTree->nearestNeighbour(tree2.get(), dynamic_cast<ItemDistance*>(&itemDistance));
diff --git a/src/operation/intersection/RectangleIntersection.cpp b/src/operation/intersection/RectangleIntersection.cpp
index e4cef09..335603a 100644
--- a/src/operation/intersection/RectangleIntersection.cpp
+++ b/src/operation/intersection/RectangleIntersection.cpp
@@ -660,14 +660,14 @@ RectangleIntersection::clip_geom(const geom::Geometry * g,
}
/* public static */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
RectangleIntersection::clipBoundary(const geom::Geometry & g, const Rectangle & rect)
{
RectangleIntersection ri(g,rect);
return ri.clipBoundary();
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
RectangleIntersection::clipBoundary()
{
RectangleIntersectionBuilder parts(*_gf);
@@ -679,14 +679,14 @@ RectangleIntersection::clipBoundary()
}
/* public static */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
RectangleIntersection::clip(const geom::Geometry & g, const Rectangle & rect)
{
RectangleIntersection ri(g,rect);
return ri.clip();
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
RectangleIntersection::clip()
{
RectangleIntersectionBuilder parts(*_gf);
diff --git a/src/operation/intersection/RectangleIntersectionBuilder.cpp b/src/operation/intersection/RectangleIntersectionBuilder.cpp
index 728462f..c341ea7 100644
--- a/src/operation/intersection/RectangleIntersectionBuilder.cpp
+++ b/src/operation/intersection/RectangleIntersectionBuilder.cpp
@@ -140,7 +140,7 @@ void RectangleIntersectionBuilder::add(geom::Point * thePoint)
points.push_back(thePoint);
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
RectangleIntersectionBuilder::build()
{
// Total number of objects
@@ -148,7 +148,7 @@ RectangleIntersectionBuilder::build()
std::size_t n = polygons.size() + lines.size() + points.size();
if(n == 0)
- return std::auto_ptr<Geometry>(_gf.createGeometryCollection());
+ return std::unique_ptr<Geometry>(_gf.createGeometryCollection());
std::vector<Geometry *> *geoms = new std::vector<Geometry *>;
geoms->reserve(n);
@@ -165,7 +165,7 @@ RectangleIntersectionBuilder::build()
geoms->push_back(*i);
points.clear();
- return std::auto_ptr<Geometry>(
+ return std::unique_ptr<Geometry>(
(*geoms)[0]->getFactory()->buildGeometry(geoms)
);
}
diff --git a/src/operation/linemerge/LineMergeGraph.cpp b/src/operation/linemerge/LineMergeGraph.cpp
index 0a92b7e..111df47 100644
--- a/src/operation/linemerge/LineMergeGraph.cpp
+++ b/src/operation/linemerge/LineMergeGraph.cpp
@@ -54,7 +54,7 @@ LineMergeGraph::addEdge(const LineString *lineString)
cerr<<"Adding LineString "<<lineString->toString()<<endl;
#endif
- std::auto_ptr<CoordinateSequence> coordinates (
+ std::unique_ptr<CoordinateSequence> coordinates (
CoordinateSequence::removeRepeatedPoints(lineString->getCoordinatesRO())
);
diff --git a/src/operation/linemerge/LineSequencer.cpp b/src/operation/linemerge/LineSequencer.cpp
index 939b506..798344f 100644
--- a/src/operation/linemerge/LineSequencer.cpp
+++ b/src/operation/linemerge/LineSequencer.cpp
@@ -183,7 +183,7 @@ LineSequencer::computeSequence()
Sequences* sequences = findSequences();
if (sequences == NULL) return;
- sequencedGeometry = auto_ptr<Geometry>(buildSequencedGeometry(*sequences));
+ sequencedGeometry = unique_ptr<Geometry>(buildSequencedGeometry(*sequences));
isSequenceableVar = true;
delAll(*sequences);
@@ -201,7 +201,7 @@ LineSequencer::computeSequence()
Geometry*
LineSequencer::buildSequencedGeometry(const Sequences& sequences)
{
- auto_ptr<Geometry::NonConstVect> lines(new Geometry::NonConstVect);
+ unique_ptr<Geometry::NonConstVect> lines(new Geometry::NonConstVect);
for (Sequences::const_iterator
i1=sequences.begin(), i1End=sequences.end();
diff --git a/src/operation/overlay/OverlayOp.cpp b/src/operation/overlay/OverlayOp.cpp
index cc87581..aa8a465 100644
--- a/src/operation/overlay/OverlayOp.cpp
+++ b/src/operation/overlay/OverlayOp.cpp
@@ -50,7 +50,7 @@
#include <functional>
#include <vector>
#include <sstream>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifndef GEOS_DEBUG
#define GEOS_DEBUG 0
diff --git a/src/operation/overlay/snap/GeometrySnapper.cpp b/src/operation/overlay/snap/GeometrySnapper.cpp
index 2a45987..f7d03f4 100644
--- a/src/operation/overlay/snap/GeometrySnapper.cpp
+++ b/src/operation/overlay/snap/GeometrySnapper.cpp
@@ -52,18 +52,18 @@ private:
const Coordinate::ConstVect& snapPts;
- CoordinateSequence::AutoPtr snapLine(
+ CoordinateSequence::Ptr snapLine(
const CoordinateSequence* srcPts)
{
- using std::auto_ptr;
+ using std::unique_ptr;
assert(srcPts);
assert(srcPts->toVector());
LineStringSnapper snapper(*(srcPts->toVector()), snapTol);
- auto_ptr<Coordinate::Vect> newPts = snapper.snapTo(snapPts);
+ unique_ptr<Coordinate::Vect> newPts = snapper.snapTo(snapPts);
const CoordinateSequenceFactory* cfact = factory->getCoordinateSequenceFactory();
- return auto_ptr<CoordinateSequence>(cfact->create(newPts.release()));
+ return unique_ptr<CoordinateSequence>(cfact->create(newPts.release()));
}
public:
@@ -76,7 +76,7 @@ public:
{
}
- CoordinateSequence::AutoPtr transformCoordinates(
+ CoordinateSequence::Ptr transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent)
{
@@ -88,10 +88,10 @@ public:
};
/*private*/
-std::auto_ptr<Coordinate::ConstVect>
+std::unique_ptr<Coordinate::ConstVect>
GeometrySnapper::extractTargetCoordinates(const Geometry& g)
{
- std::auto_ptr<Coordinate::ConstVect> snapPts(new Coordinate::ConstVect());
+ std::unique_ptr<Coordinate::ConstVect> snapPts(new Coordinate::ConstVect());
util::UniqueCoordinateArrayFilter filter(*snapPts);
g.apply_ro(&filter);
// integrity check
@@ -100,36 +100,36 @@ GeometrySnapper::extractTargetCoordinates(const Geometry& g)
}
/*public*/
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
GeometrySnapper::snapTo(const geom::Geometry& g, double snapTolerance)
{
- using std::auto_ptr;
+ using std::unique_ptr;
using geom::util::GeometryTransformer;
// Get snap points
- auto_ptr<Coordinate::ConstVect> snapPts=extractTargetCoordinates(g);
+ unique_ptr<Coordinate::ConstVect> snapPts=extractTargetCoordinates(g);
// Apply a SnapTransformer to source geometry
// (we need a pointer for dynamic polymorphism)
- auto_ptr<GeometryTransformer> snapTrans(new SnapTransformer(snapTolerance, *snapPts));
+ unique_ptr<GeometryTransformer> snapTrans(new SnapTransformer(snapTolerance, *snapPts));
return snapTrans->transform(&srcGeom);
}
/*public*/
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
GeometrySnapper::snapToSelf(double snapTolerance, bool cleanResult)
{
- using std::auto_ptr;
+ using std::unique_ptr;
using geom::util::GeometryTransformer;
// Get snap points
- auto_ptr<Coordinate::ConstVect> snapPts=extractTargetCoordinates(srcGeom);
+ unique_ptr<Coordinate::ConstVect> snapPts=extractTargetCoordinates(srcGeom);
// Apply a SnapTransformer to source geometry
// (we need a pointer for dynamic polymorphism)
- auto_ptr<GeometryTransformer> snapTrans(new SnapTransformer(snapTolerance, *snapPts));
+ unique_ptr<GeometryTransformer> snapTrans(new SnapTransformer(snapTolerance, *snapPts));
GeomPtr result = snapTrans->transform(&srcGeom);
diff --git a/src/operation/overlay/snap/LineStringSnapper.cpp b/src/operation/overlay/snap/LineStringSnapper.cpp
index dfb8608..c15915d 100644
--- a/src/operation/overlay/snap/LineStringSnapper.cpp
+++ b/src/operation/overlay/snap/LineStringSnapper.cpp
@@ -50,7 +50,7 @@ namespace overlay { // geos.operation.overlay
namespace snap { // geos.operation.overlay.snap
/*public*/
-std::auto_ptr<Coordinate::Vect>
+std::unique_ptr<Coordinate::Vect>
LineStringSnapper::snapTo(const geom::Coordinate::ConstVect& snapPts)
{
geom::CoordinateList coordList(srcPts);
diff --git a/src/operation/overlay/snap/SnapIfNeededOverlayOp.cpp b/src/operation/overlay/snap/SnapIfNeededOverlayOp.cpp
index 7094d4d..9da6254 100644
--- a/src/operation/overlay/snap/SnapIfNeededOverlayOp.cpp
+++ b/src/operation/overlay/snap/SnapIfNeededOverlayOp.cpp
@@ -19,12 +19,12 @@
#include <geos/operation/overlay/snap/SnapIfNeededOverlayOp.h>
#include <geos/operation/overlay/snap/SnapOverlayOp.h>
#include <geos/operation/overlay/OverlayOp.h>
-#include <geos/geom/Geometry.h> // for use in auto_ptr
+#include <geos/geom/Geometry.h> // for use in unique_ptr
#include <geos/util.h>
#include <cassert>
#include <limits> // for numeric_limits
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifndef GEOS_DEBUG
#define GEOS_DEBUG 0
@@ -39,12 +39,12 @@ namespace overlay { // geos.operation.overlay
namespace snap { // geos.operation.overlay.snap
/* public */
-auto_ptr<Geometry>
+unique_ptr<Geometry>
SnapIfNeededOverlayOp::getResultGeometry(OverlayOp::OpCode opCode)
{
using geos::util::TopologyException;
- auto_ptr<Geometry> result;
+ unique_ptr<Geometry> result;
TopologyException origEx;
diff --git a/src/operation/overlay/snap/SnapOverlayOp.cpp b/src/operation/overlay/snap/SnapOverlayOp.cpp
index a6c5e0c..3b09324 100644
--- a/src/operation/overlay/snap/SnapOverlayOp.cpp
+++ b/src/operation/overlay/snap/SnapOverlayOp.cpp
@@ -23,7 +23,7 @@
#include <cassert>
#include <limits> // for numeric_limits
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifndef GEOS_DEBUG
#define GEOS_DEBUG 0
@@ -48,7 +48,7 @@ SnapOverlayOp::computeSnapTolerance()
}
/* public */
-auto_ptr<Geometry>
+unique_ptr<Geometry>
SnapOverlayOp::getResultGeometry(OverlayOp::OpCode opCode)
{
geom::GeomPtrPair prepGeom;
diff --git a/src/operation/overlay/validate/FuzzyPointLocator.cpp b/src/operation/overlay/validate/FuzzyPointLocator.cpp
index 66055c9..f8d7449 100644
--- a/src/operation/overlay/validate/FuzzyPointLocator.cpp
+++ b/src/operation/overlay/validate/FuzzyPointLocator.cpp
@@ -27,7 +27,7 @@
#include <functional>
#include <vector>
#include <sstream>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#ifndef GEOS_DEBUG
#define GEOS_DEBUG 0
@@ -57,7 +57,7 @@ FuzzyPointLocator::FuzzyPointLocator(const geom::Geometry& geom,
}
/*private*/
-std::auto_ptr<Geometry>
+std::unique_ptr<Geometry>
FuzzyPointLocator::extractLineWork(const geom::Geometry& geom)
{
::geos::ignore_unused_variable_warning(geom);
@@ -76,7 +76,7 @@ FuzzyPointLocator::extractLineWork(const geom::Geometry& geom)
lineGeoms->push_back(lineGeom);
}
}
- return std::auto_ptr<Geometry>(g.getFactory()->buildGeometry(lineGeoms));
+ return std::unique_ptr<Geometry>(g.getFactory()->buildGeometry(lineGeoms));
} catch (...) { // avoid leaks
for (size_t i=0, n=lineGeoms->size(); i<n; ++i)
@@ -90,7 +90,7 @@ FuzzyPointLocator::extractLineWork(const geom::Geometry& geom)
}
/*private*/
-std::auto_ptr<Geometry>
+std::unique_ptr<Geometry>
FuzzyPointLocator::getLineWork(const geom::Geometry& geom)
{
::geos::ignore_unused_variable_warning(geom);
@@ -110,7 +110,7 @@ FuzzyPointLocator::getLineWork(const geom::Geometry& geom)
}
lineGeoms->push_back(lineGeom);
}
- return std::auto_ptr<Geometry>(g.getFactory()->buildGeometry(lineGeoms));
+ return std::unique_ptr<Geometry>(g.getFactory()->buildGeometry(lineGeoms));
} catch (...) { // avoid leaks
for (size_t i=0, n=lineGeoms->size(); i<n; ++i)
@@ -128,7 +128,7 @@ FuzzyPointLocator::getLineWork(const geom::Geometry& geom)
Location::Value
FuzzyPointLocator::getLocation(const Coordinate& pt)
{
- auto_ptr<Geometry> point(g.getFactory()->createPoint(pt));
+ unique_ptr<Geometry> point(g.getFactory()->createPoint(pt));
double dist = linework->distance(point.get());
diff --git a/src/operation/overlay/validate/OffsetPointGenerator.cpp b/src/operation/overlay/validate/OffsetPointGenerator.cpp
index c28081b..127a923 100644
--- a/src/operation/overlay/validate/OffsetPointGenerator.cpp
+++ b/src/operation/overlay/validate/OffsetPointGenerator.cpp
@@ -27,7 +27,7 @@
#include <cassert>
#include <functional>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cmath>
#include <algorithm> // std::for_each
@@ -54,7 +54,7 @@ OffsetPointGenerator::OffsetPointGenerator(const geom::Geometry& geom,
}
/*public*/
-std::auto_ptr< std::vector<geom::Coordinate> >
+std::unique_ptr< std::vector<geom::Coordinate> >
OffsetPointGenerator::getPoints()
{
assert (offsetPts.get() == NULL);
@@ -65,7 +65,8 @@ OffsetPointGenerator::getPoints()
for_each(lines.begin(), lines.end(),
bind1st(mem_fun(&OffsetPointGenerator::extractPoints), this));
- return offsetPts;
+ // NOTE: Apparently, this is 'source' method giving up the object resource.
+ return std::move(offsetPts);
}
/*private*/
diff --git a/src/operation/overlay/validate/OverlayResultValidator.cpp b/src/operation/overlay/validate/OverlayResultValidator.cpp
index 601045b..ee099e5 100644
--- a/src/operation/overlay/validate/OverlayResultValidator.cpp
+++ b/src/operation/overlay/validate/OverlayResultValidator.cpp
@@ -28,7 +28,7 @@
#include <cassert>
#include <functional>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <algorithm> // for std::min etc.
#ifndef GEOS_DEBUG
@@ -67,17 +67,17 @@ isArea(const Geometry& g)
return false;
}
-auto_ptr<MultiPoint>
+unique_ptr<MultiPoint>
toMultiPoint(vector<Coordinate>& coords)
{
const GeometryFactory& gf = *(GeometryFactory::getDefaultInstance());
const CoordinateSequenceFactory& csf =
*(gf.getCoordinateSequenceFactory());
- auto_ptr< vector<Coordinate> > nc ( new vector<Coordinate>(coords) );
- auto_ptr<CoordinateSequence> cs(csf.create(nc.release()));
+ unique_ptr< vector<Coordinate> > nc ( new vector<Coordinate>(coords) );
+ unique_ptr<CoordinateSequence> cs(csf.create(nc.release()));
- auto_ptr<MultiPoint> mp ( gf.createMultiPoint(*cs) );
+ unique_ptr<MultiPoint> mp ( gf.createMultiPoint(*cs) );
return mp;
}
@@ -153,7 +153,7 @@ void
OverlayResultValidator::addTestPts(const Geometry& g)
{
OffsetPointGenerator ptGen(g, 5 * boundaryDistanceTolerance);
- auto_ptr< vector<geom::Coordinate> > pts = ptGen.getPoints();
+ unique_ptr< vector<geom::Coordinate> > pts = ptGen.getPoints();
testCoords.insert(testCoords.end(), pts->begin(), pts->end());
}
@@ -163,7 +163,7 @@ OverlayResultValidator::addVertices(const Geometry& g)
{
// TODO: optimize this by not copying coordinates
// and pre-allocating memory
- auto_ptr<CoordinateSequence> cs ( g.getCoordinates() );
+ unique_ptr<CoordinateSequence> cs ( g.getCoordinates() );
const vector<Coordinate>* coords = cs->toVector();
testCoords.insert(testCoords.end(), coords->begin(), coords->end());
}
diff --git a/src/operation/relate/RelateComputer.cpp b/src/operation/relate/RelateComputer.cpp
index 996a90d..2144142 100644
--- a/src/operation/relate/RelateComputer.cpp
+++ b/src/operation/relate/RelateComputer.cpp
@@ -88,7 +88,7 @@ RelateComputer::computeIM()
<< std::endl;
#endif
- std::auto_ptr<SegmentIntersector> si1 (
+ std::unique_ptr<SegmentIntersector> si1 (
(*arg)[0]->computeSelfNodes(&li,false)
);
@@ -100,7 +100,7 @@ RelateComputer::computeIM()
<< std::endl;
#endif
- std::auto_ptr<SegmentIntersector> si2 (
+ std::unique_ptr<SegmentIntersector> si2 (
(*arg)[1]->computeSelfNodes(&li,false)
);
@@ -113,7 +113,7 @@ RelateComputer::computeIM()
#endif
// compute intersections between edges of the two input geometries
- std::auto_ptr< SegmentIntersector> intersector (
+ std::unique_ptr< SegmentIntersector> intersector (
(*arg)[0]->computeEdgeIntersections((*arg)[1], &li,false)
);
@@ -189,11 +189,11 @@ RelateComputer::computeIM()
*/
// build EdgeEnds for all intersections
EdgeEndBuilder eeBuilder;
- std::auto_ptr< std::vector<EdgeEnd*> > ee0 (
+ std::unique_ptr< std::vector<EdgeEnd*> > ee0 (
eeBuilder.computeEdgeEnds((*arg)[0]->getEdges())
);
insertEdgeEnds(ee0.get());
- std::auto_ptr< std::vector<EdgeEnd*> > ee1 (
+ std::unique_ptr< std::vector<EdgeEnd*> > ee1 (
eeBuilder.computeEdgeEnds((*arg)[1]->getEdges())
);
diff --git a/src/operation/sharedpaths/SharedPathsOp.cpp b/src/operation/sharedpaths/SharedPathsOp.cpp
index 0a94387..62bfc37 100644
--- a/src/operation/sharedpaths/SharedPathsOp.cpp
+++ b/src/operation/sharedpaths/SharedPathsOp.cpp
@@ -108,7 +108,7 @@ SharedPathsOp::findLinearIntersections(PathList& to)
// TODO: optionally use the tolerance,
// snapping _g2 over _g1 ?
- std::auto_ptr<Geometry> full ( OverlayOp::overlayOp(
+ std::unique_ptr<Geometry> full ( OverlayOp::overlayOp(
&_g1, &_g2, OverlayOp::opINTERSECTION) );
// NOTE: intersection of equal lines yelds splitted lines,
diff --git a/src/operation/union/CascadedPolygonUnion.cpp b/src/operation/union/CascadedPolygonUnion.cpp
index 95b53f3..04c2328 100644
--- a/src/operation/union/CascadedPolygonUnion.cpp
+++ b/src/operation/union/CascadedPolygonUnion.cpp
@@ -146,7 +146,7 @@ geom::Geometry* CascadedPolygonUnion::Union()
index.insert(g->getEnvelopeInternal(), g);
}
- std::auto_ptr<index::strtree::ItemsList> itemTree (index.itemsTree());
+ std::unique_ptr<index::strtree::ItemsList> itemTree (index.itemsTree());
return unionTree(itemTree.get());
}
@@ -158,7 +158,7 @@ geom::Geometry* CascadedPolygonUnion::unionTree(
* Recursively unions all subtrees in the list into single geometries.
* The result is a list of Geometry's only
*/
- std::auto_ptr<GeometryListHolder> geoms(reduceToGeometries(geomTree));
+ std::unique_ptr<GeometryListHolder> geoms(reduceToGeometries(geomTree));
return binaryUnion(geoms.get());
}
@@ -179,8 +179,8 @@ geom::Geometry* CascadedPolygonUnion::binaryUnion(GeometryListHolder* geoms,
else {
// recurse on both halves of the list
std::size_t mid = (end + start) / 2;
- std::auto_ptr<geom::Geometry> g0 (binaryUnion(geoms, start, mid));
- std::auto_ptr<geom::Geometry> g1 (binaryUnion(geoms, mid, end));
+ std::unique_ptr<geom::Geometry> g0 (binaryUnion(geoms, start, mid));
+ std::unique_ptr<geom::Geometry> g1 (binaryUnion(geoms, mid, end));
return unionSafe(g0.get(), g1.get());
}
}
@@ -188,13 +188,13 @@ geom::Geometry* CascadedPolygonUnion::binaryUnion(GeometryListHolder* geoms,
GeometryListHolder*
CascadedPolygonUnion::reduceToGeometries(index::strtree::ItemsList* geomTree)
{
- std::auto_ptr<GeometryListHolder> geoms (new GeometryListHolder());
+ std::unique_ptr<GeometryListHolder> geoms (new GeometryListHolder());
typedef index::strtree::ItemsList::iterator iterator_type;
iterator_type end = geomTree->end();
for (iterator_type i = geomTree->begin(); i != end; ++i) {
if ((*i).get_type() == index::strtree::ItemsListItem::item_is_list) {
- std::auto_ptr<geom::Geometry> geom (unionTree((*i).get_itemslist()));
+ std::unique_ptr<geom::Geometry> geom (unionTree((*i).get_itemslist()));
geoms->push_back_owned(geom.get());
geom.release();
}
@@ -252,15 +252,15 @@ CascadedPolygonUnion::unionUsingEnvelopeIntersection(geom::Geometry* g0,
check_valid(*g1, "unionUsingEnvelopeIntersection g1");
#endif
- std::auto_ptr<geom::Geometry> g0Int(extractByEnvelope(common, g0, disjointPolys));
- std::auto_ptr<geom::Geometry> g1Int(extractByEnvelope(common, g1, disjointPolys));
+ std::unique_ptr<geom::Geometry> g0Int(extractByEnvelope(common, g0, disjointPolys));
+ std::unique_ptr<geom::Geometry> g1Int(extractByEnvelope(common, g1, disjointPolys));
#if GEOS_DEBUG_CASCADED_UNION
check_valid(*g0Int, "unionUsingEnvelopeIntersection g0Int");
check_valid(*g1Int, "unionUsingEnvelopeIntersection g1Int");
#endif
- std::auto_ptr<geom::Geometry> u(unionActual(g0Int.get(), g1Int.get()));
+ std::unique_ptr<geom::Geometry> u(unionActual(g0Int.get(), g1Int.get()));
#if GEOS_DEBUG_CASCADED_UNION
if ( ! check_valid(*u, "unionUsingEnvelopeIntersection unionActual return") )
@@ -300,7 +300,7 @@ CascadedPolygonUnion::unionUsingEnvelopeIntersection(geom::Geometry* g0,
std::cerr << "unionUsingEnvelopeIntersection: " << polysOn.size() << "/" << disjointPolys.size() << " polys intersect union of final thing" << std::endl;
#endif
- std::auto_ptr<geom::Geometry> ret;
+ std::unique_ptr<geom::Geometry> ret;
if ( polysOn.empty() ) {
disjointPolys.push_back(u.get());
ret.reset( geom::util::GeometryCombiner::combine(disjointPolys));
@@ -367,11 +367,11 @@ CascadedPolygonUnion::extractByEnvelope(geom::Envelope const& env,
geom::Geometry*
CascadedPolygonUnion::unionActual(geom::Geometry* g0, geom::Geometry* g1)
{
- return restrictToPolygons(std::auto_ptr<geom::Geometry>(g0->Union(g1))).release();
+ return restrictToPolygons(std::unique_ptr<geom::Geometry>(g0->Union(g1))).release();
}
-std::auto_ptr<geom::Geometry>
-CascadedPolygonUnion::restrictToPolygons(std::auto_ptr<geom::Geometry> g)
+std::unique_ptr<geom::Geometry>
+CascadedPolygonUnion::restrictToPolygons(std::unique_ptr<geom::Geometry> g)
{
using namespace geom;
using namespace std;
@@ -384,7 +384,7 @@ CascadedPolygonUnion::restrictToPolygons(std::auto_ptr<geom::Geometry> g)
geom::util::PolygonExtracter::getPolygons(*g, polygons);
if (polygons.size() == 1)
- return std::auto_ptr<Geometry>(polygons[0]->clone());
+ return std::unique_ptr<Geometry>(polygons[0]->clone());
typedef vector<Geometry *> GeomVect;
@@ -393,7 +393,7 @@ CascadedPolygonUnion::restrictToPolygons(std::auto_ptr<geom::Geometry> g)
for (Polygon::ConstVect::size_type i=0; i<n; ++i) {
(*newpolys)[i] = polygons[i]->clone();
}
- return auto_ptr<Geometry>(
+ return unique_ptr<Geometry>(
g->getFactory()->createMultiPolygon(newpolys)
);
diff --git a/src/operation/union/CascadedUnion.cpp b/src/operation/union/CascadedUnion.cpp
index 825b830..e9b57f0 100644
--- a/src/operation/union/CascadedUnion.cpp
+++ b/src/operation/union/CascadedUnion.cpp
@@ -60,7 +60,7 @@ geom::Geometry* CascadedUnion::Union()
index.insert(g->getEnvelopeInternal(), g);
}
- std::auto_ptr<index::strtree::ItemsList> itemTree (index.itemsTree());
+ std::unique_ptr<index::strtree::ItemsList> itemTree (index.itemsTree());
return unionTree(itemTree.get());
}
@@ -72,7 +72,7 @@ geom::Geometry* CascadedUnion::unionTree(
* Recursively unions all subtrees in the list into single geometries.
* The result is a list of Geometry's only
*/
- std::auto_ptr<GeometryListHolder> geoms(reduceToGeometries(geomTree));
+ std::unique_ptr<GeometryListHolder> geoms(reduceToGeometries(geomTree));
return binaryUnion(geoms.get());
}
@@ -93,8 +93,8 @@ geom::Geometry* CascadedUnion::binaryUnion(GeometryListHolder* geoms,
else {
// recurse on both halves of the list
std::size_t mid = (end + start) / 2;
- std::auto_ptr<geom::Geometry> g0 (binaryUnion(geoms, start, mid));
- std::auto_ptr<geom::Geometry> g1 (binaryUnion(geoms, mid, end));
+ std::unique_ptr<geom::Geometry> g0 (binaryUnion(geoms, start, mid));
+ std::unique_ptr<geom::Geometry> g1 (binaryUnion(geoms, mid, end));
return unionSafe(g0.get(), g1.get());
}
}
@@ -102,13 +102,13 @@ geom::Geometry* CascadedUnion::binaryUnion(GeometryListHolder* geoms,
GeometryListHolder*
CascadedUnion::reduceToGeometries(index::strtree::ItemsList* geomTree)
{
- std::auto_ptr<GeometryListHolder> geoms (new GeometryListHolder());
+ std::unique_ptr<GeometryListHolder> geoms (new GeometryListHolder());
typedef index::strtree::ItemsList::iterator iterator_type;
iterator_type end = geomTree->end();
for (iterator_type i = geomTree->begin(); i != end; ++i) {
if ((*i).get_type() == index::strtree::ItemsListItem::item_is_list) {
- std::auto_ptr<geom::Geometry> geom (unionTree((*i).get_itemslist()));
+ std::unique_ptr<geom::Geometry> geom (unionTree((*i).get_itemslist()));
geoms->push_back_owned(geom.get());
geom.release();
}
@@ -160,10 +160,10 @@ CascadedUnion::unionUsingEnvelopeIntersection(geom::Geometry* g0,
{
std::vector<geom::Geometry*> disjointPolys;
- std::auto_ptr<geom::Geometry> g0Int(extractByEnvelope(common, g0, disjointPolys));
- std::auto_ptr<geom::Geometry> g1Int(extractByEnvelope(common, g1, disjointPolys));
+ std::unique_ptr<geom::Geometry> g0Int(extractByEnvelope(common, g0, disjointPolys));
+ std::unique_ptr<geom::Geometry> g1Int(extractByEnvelope(common, g1, disjointPolys));
- std::auto_ptr<geom::Geometry> u(unionActual(g0Int.get(), g1Int.get()));
+ std::unique_ptr<geom::Geometry> u(unionActual(g0Int.get(), g1Int.get()));
disjointPolys.push_back(u.get());
return geom::util::GeometryCombiner::combine(disjointPolys);
diff --git a/src/operation/union/PointGeometryUnion.cpp b/src/operation/union/PointGeometryUnion.cpp
index a6f3a64..5bc7988 100644
--- a/src/operation/union/PointGeometryUnion.cpp
+++ b/src/operation/union/PointGeometryUnion.cpp
@@ -16,7 +16,7 @@
*
**********************************************************************/
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cassert> // for assert
#include <algorithm> // for copy
#include <geos/operation/union/PointGeometryUnion.h>
@@ -35,7 +35,7 @@ namespace operation { // geos::operation
namespace geounion { // geos::operation::geounion
/* public */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
PointGeometryUnion::Union() const
{
using namespace geom;
@@ -57,10 +57,10 @@ PointGeometryUnion::Union() const
// if no points are in exterior, return the other geom
if (exteriorCoords.empty())
- return std::auto_ptr<Geometry>(otherGeom.clone());
+ return std::unique_ptr<Geometry>(otherGeom.clone());
// make a puntal geometry of appropriate size
- std::auto_ptr<Geometry> ptComp;
+ std::unique_ptr<Geometry> ptComp;
if (exteriorCoords.size() == 1) {
ptComp.reset( geomFact->createPoint(*(exteriorCoords.begin())) );
@@ -73,13 +73,13 @@ PointGeometryUnion::Union() const
}
// add point component to the other geometry
- return std::auto_ptr<Geometry> (
+ return std::unique_ptr<Geometry> (
GeometryCombiner::combine(ptComp.get(), &otherGeom)
);
}
/* public static */
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
PointGeometryUnion::Union(const geom::Puntal& pointGeom,
const geom::Geometry& otherGeom)
{
diff --git a/src/operation/union/UnaryUnionOp.cpp b/src/operation/union/UnaryUnionOp.cpp
index 1d6093c..5a1cd6d 100644
--- a/src/operation/union/UnaryUnionOp.cpp
+++ b/src/operation/union/UnaryUnionOp.cpp
@@ -16,7 +16,7 @@
*
**********************************************************************/
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cassert> // for assert
#include <algorithm> // for copy
@@ -42,11 +42,11 @@ namespace operation { // geos::operation
namespace geounion { // geos::operation::geounion
/*private*/
-std::auto_ptr<geom::Geometry>
-UnaryUnionOp::unionWithNull(std::auto_ptr<geom::Geometry> g0,
- std::auto_ptr<geom::Geometry> g1)
+std::unique_ptr<geom::Geometry>
+UnaryUnionOp::unionWithNull(std::unique_ptr<geom::Geometry> g0,
+ std::unique_ptr<geom::Geometry> g1)
{
- std::auto_ptr<geom::Geometry> ret;
+ std::unique_ptr<geom::Geometry> ret;
if ( ( ! g0.get() ) && ( ! g1.get() ) ) return ret;
if ( ! g0.get() ) return g1;
@@ -57,13 +57,13 @@ UnaryUnionOp::unionWithNull(std::auto_ptr<geom::Geometry> g0,
}
/*public*/
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
UnaryUnionOp::Union()
{
using geom::Puntal;
- typedef std::auto_ptr<geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
- GeomAutoPtr ret;
+ GeomPtr ret;
if ( ! geomFact ) return ret;
/**
@@ -73,14 +73,14 @@ UnaryUnionOp::Union()
* This is not the case for polygons, so Cascaded Union is required.
*/
- GeomAutoPtr unionPoints;
+ GeomPtr unionPoints;
if (!points.empty()) {
- GeomAutoPtr ptGeom = geomFact->buildGeometry( points.begin(),
+ GeomPtr ptGeom = geomFact->buildGeometry( points.begin(),
points.end() );
unionPoints = unionNoOpt(*ptGeom);
}
- GeomAutoPtr unionLines;
+ GeomPtr unionLines;
if (!lines.empty()) {
/* JTS compatibility NOTE:
* we use cascaded here for robustness [1]
@@ -96,7 +96,7 @@ UnaryUnionOp::Union()
unionLines = unionNoOpt(*unionLines);
}
- GeomAutoPtr unionPolygons;
+ GeomPtr unionPolygons;
if (!polygons.empty()) {
unionPolygons.reset( CascadedPolygonUnion::Union( polygons.begin(),
polygons.end() ) );
@@ -107,15 +107,15 @@ UnaryUnionOp::Union()
* but is mitigated by unioning lines and points first
*/
- GeomAutoPtr unionLA = unionWithNull(unionLines, unionPolygons);
+ GeomPtr unionLA = unionWithNull(std::move(unionLines), std::move(unionPolygons));
assert(!unionLines.get()); assert(!unionPolygons.get());
if ( ! unionPoints.get() ) {
- ret = unionLA;
+ ret = std::move(unionLA);
assert(!unionLA.get());
}
else if ( ! unionLA.get() ) {
- ret = unionPoints;
+ ret = std::move(unionPoints);
assert(!unionPoints.get());
}
else {
diff --git a/src/operation/valid/ConsistentAreaTester.cpp b/src/operation/valid/ConsistentAreaTester.cpp
index 79ad036..451e5b9 100644
--- a/src/operation/valid/ConsistentAreaTester.cpp
+++ b/src/operation/valid/ConsistentAreaTester.cpp
@@ -29,7 +29,7 @@
#include <geos/operation/relate/RelateNode.h>
#include <geos/operation/relate/EdgeEndBundle.h>
-#include <memory> // auto_ptr
+#include <memory> // unique_ptr
#include <cassert>
using namespace std;
@@ -69,7 +69,7 @@ ConsistentAreaTester::isNodeConsistentArea()
* To fully check validity, it is necessary to
* compute ALL intersections, including self-intersections within a single edge.
*/
- auto_ptr<SegmentIntersector> intersector(geomGraph->computeSelfNodes(&li, true, true));
+ unique_ptr<SegmentIntersector> intersector(geomGraph->computeSelfNodes(&li, true, true));
/**
* A proper intersection means that the area is not consistent.
*/
diff --git a/src/operation/valid/IndexedNestedRingTester.h b/src/operation/valid/IndexedNestedRingTester.h
index 53e9012..eb6407b 100644
--- a/src/operation/valid/IndexedNestedRingTester.h
+++ b/src/operation/valid/IndexedNestedRingTester.h
@@ -91,7 +91,7 @@ private:
// CHECK: Owned by (seems unused)?
//geom::Envelope* totalEnv;
- // Owned by us (use auto_ptr ?)
+ // Owned by us (use unique_ptr ?)
geos::index::SpatialIndex* index; // 'index' in JTS
// Externally owned, if not null
diff --git a/src/precision/CommonBitsOp.cpp b/src/precision/CommonBitsOp.cpp
index 4ccc6c4..e8549c8 100644
--- a/src/precision/CommonBitsOp.cpp
+++ b/src/precision/CommonBitsOp.cpp
@@ -67,8 +67,8 @@ CommonBitsOp::intersection(
const Geometry* geom0,
const Geometry* geom1)
{
- auto_ptr<Geometry> rgeom0;
- auto_ptr<Geometry> rgeom1;
+ unique_ptr<Geometry> rgeom0;
+ unique_ptr<Geometry> rgeom1;
removeCommonBits(geom0, geom1, rgeom0, rgeom1);
return computeResultPrecision(rgeom0->intersection(rgeom1.get()));
}
@@ -79,8 +79,8 @@ CommonBitsOp::Union(
const Geometry* geom0,
const Geometry* geom1)
{
- auto_ptr<Geometry> rgeom0;
- auto_ptr<Geometry> rgeom1;
+ unique_ptr<Geometry> rgeom0;
+ unique_ptr<Geometry> rgeom1;
removeCommonBits(geom0, geom1, rgeom0, rgeom1);
return computeResultPrecision(rgeom0->Union(rgeom1.get()));
}
@@ -91,8 +91,8 @@ CommonBitsOp::difference(
const Geometry* geom0,
const Geometry* geom1)
{
- auto_ptr<Geometry> rgeom0;
- auto_ptr<Geometry> rgeom1;
+ unique_ptr<Geometry> rgeom0;
+ unique_ptr<Geometry> rgeom1;
removeCommonBits(geom0, geom1, rgeom0, rgeom1);
return computeResultPrecision(rgeom0->difference(rgeom1.get()));
}
@@ -103,8 +103,8 @@ CommonBitsOp::symDifference(
const Geometry* geom0,
const Geometry* geom1)
{
- auto_ptr<Geometry> rgeom0;
- auto_ptr<Geometry> rgeom1;
+ unique_ptr<Geometry> rgeom0;
+ unique_ptr<Geometry> rgeom1;
removeCommonBits(geom0, geom1, rgeom0, rgeom1);
return computeResultPrecision(rgeom0->symDifference(rgeom1.get()));
}
@@ -113,7 +113,7 @@ CommonBitsOp::symDifference(
Geometry*
CommonBitsOp::buffer(const Geometry* geom0, double distance)
{
- auto_ptr<Geometry> rgeom0(removeCommonBits(geom0));
+ unique_ptr<Geometry> rgeom0(removeCommonBits(geom0));
return computeResultPrecision(rgeom0->buffer(distance));
}
@@ -148,8 +148,8 @@ void
CommonBitsOp::removeCommonBits(
const geom::Geometry* geom0,
const geom::Geometry* geom1,
- std::auto_ptr<geom::Geometry>& rgeom0,
- std::auto_ptr<geom::Geometry>& rgeom1)
+ std::unique_ptr<geom::Geometry>& rgeom0,
+ std::unique_ptr<geom::Geometry>& rgeom1)
{
cbr.reset(new CommonBitsRemover());
diff --git a/src/precision/EnhancedPrecisionOp.cpp b/src/precision/EnhancedPrecisionOp.cpp
index da7d7a3..abba62e 100644
--- a/src/precision/EnhancedPrecisionOp.cpp
+++ b/src/precision/EnhancedPrecisionOp.cpp
@@ -19,7 +19,7 @@
#include <geos/precision/EnhancedPrecisionOp.h>
#include <geos/precision/CommonBitsOp.h>
-#include <geos/precision/CommonBitsRemover.h> // for auto_ptr composition
+#include <geos/precision/CommonBitsRemover.h> // for unique_ptr composition
#include <geos/geom/Geometry.h>
#include <geos/util/GEOSException.h>
diff --git a/src/precision/GeometryPrecisionReducer.cpp b/src/precision/GeometryPrecisionReducer.cpp
index 84eeabc..a5923ee 100644
--- a/src/precision/GeometryPrecisionReducer.cpp
+++ b/src/precision/GeometryPrecisionReducer.cpp
@@ -41,10 +41,10 @@ namespace precision { // geos.precision
/* private */
-auto_ptr<Geometry>
+unique_ptr<Geometry>
GeometryPrecisionReducer::reducePointwise(const Geometry &geom)
{
- auto_ptr<GeometryEditor> geomEdit;
+ unique_ptr<GeometryEditor> geomEdit;
if ( newFactory ) {
geomEdit.reset( new GeometryEditor(newFactory) );
@@ -62,16 +62,16 @@ GeometryPrecisionReducer::reducePointwise(const Geometry &geom)
PrecisionReducerCoordinateOperation prco(targetPM, finalRemoveCollapsed);
- std::auto_ptr<Geometry> g ( geomEdit->edit(&geom, &prco) );
+ std::unique_ptr<Geometry> g ( geomEdit->edit(&geom, &prco) );
return g;
}
/* public */
-auto_ptr<Geometry>
+unique_ptr<Geometry>
GeometryPrecisionReducer::reduce(const Geometry &geom)
{
- auto_ptr<Geometry> reducePW = reducePointwise(geom);
+ unique_ptr<Geometry> reducePW = reducePointwise(geom);
if ( isPointwise ) return reducePW;
@@ -99,15 +99,15 @@ GeometryPrecisionReducer::GeometryPrecisionReducer(const GeometryFactory &change
{}
/* private */
-auto_ptr<Geometry>
+unique_ptr<Geometry>
GeometryPrecisionReducer::fixPolygonalTopology(const geom::Geometry& geom )
{
/**
* If precision model was *not* changed, need to flip
* geometry to targetPM, buffer in that model, then flip back
*/
- auto_ptr<Geometry> tmp;
- GeometryFactory::unique_ptr tmpFactory;
+ unique_ptr<Geometry> tmp;
+ GeometryFactory::Ptr tmpFactory;
const Geometry* geomToBuffer = &geom;
@@ -117,7 +117,7 @@ GeometryPrecisionReducer::fixPolygonalTopology(const geom::Geometry& geom )
geomToBuffer = tmp.get();
}
- auto_ptr<Geometry> bufGeom ( geomToBuffer->buffer(0) );
+ unique_ptr<Geometry> bufGeom ( geomToBuffer->buffer(0) );
if ( ! newFactory ) {
// a slick way to copy the geometry with the original precision factory
@@ -128,11 +128,11 @@ GeometryPrecisionReducer::fixPolygonalTopology(const geom::Geometry& geom )
}
/* private */
-GeometryFactory::unique_ptr
+GeometryFactory::Ptr
GeometryPrecisionReducer::createFactory( const GeometryFactory& oldGF,
const PrecisionModel& newPM )
{
- GeometryFactory::unique_ptr newFactory(
+ GeometryFactory::Ptr newFactory(
GeometryFactory::create(&newPM,
oldGF.getSRID(),
const_cast<CoordinateSequenceFactory*>(oldGF.getCoordinateSequenceFactory()))
diff --git a/src/precision/MinimumClearance.cpp b/src/precision/MinimumClearance.cpp
index 3799ee6..c30b3ac 100644
--- a/src/precision/MinimumClearance.cpp
+++ b/src/precision/MinimumClearance.cpp
@@ -39,14 +39,14 @@ double MinimumClearance::getDistance() {
return minClearance;
}
-std::auto_ptr<LineString> MinimumClearance::getLine() {
+std::unique_ptr<LineString> MinimumClearance::getLine() {
compute();
// return empty line string if no min pts were found
if (minClearance == std::numeric_limits<double>::infinity())
- return std::auto_ptr<LineString>(inputGeom->getFactory()->createLineString());
+ return std::unique_ptr<LineString>(inputGeom->getFactory()->createLineString());
- return std::auto_ptr<LineString>(inputGeom->getFactory()->createLineString(minClearancePts->clone()));
+ return std::unique_ptr<LineString>(inputGeom->getFactory()->createLineString(minClearancePts->clone()));
}
void MinimumClearance::compute() {
@@ -165,7 +165,7 @@ void MinimumClearance::compute() {
return;
// initialize to "No Distance Exists" state
- minClearancePts = std::auto_ptr<CoordinateSequence>(inputGeom->getFactory()->getCoordinateSequenceFactory()->create(2, 2));
+ minClearancePts = std::unique_ptr<CoordinateSequence>(inputGeom->getFactory()->getCoordinateSequenceFactory()->create(2, 2));
minClearance = std::numeric_limits<double>::infinity();
// handle empty geometries
diff --git a/src/simplify/DouglasPeuckerLineSimplifier.cpp b/src/simplify/DouglasPeuckerLineSimplifier.cpp
index ad85b7d..d10c022 100644
--- a/src/simplify/DouglasPeuckerLineSimplifier.cpp
+++ b/src/simplify/DouglasPeuckerLineSimplifier.cpp
@@ -21,7 +21,7 @@
#include <geos/geom/LineSegment.h>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
namespace geos {
@@ -75,7 +75,7 @@ DouglasPeuckerLineSimplifier::simplify()
}
}
- // auto_ptr transfer ownership to its
+ // unique_ptr transfer ownership to its
// returned copy
return coordList;
}
diff --git a/src/simplify/DouglasPeuckerSimplifier.cpp b/src/simplify/DouglasPeuckerSimplifier.cpp
index 0657645..239b71b 100644
--- a/src/simplify/DouglasPeuckerSimplifier.cpp
+++ b/src/simplify/DouglasPeuckerSimplifier.cpp
@@ -18,16 +18,16 @@
#include <geos/simplify/DouglasPeuckerSimplifier.h>
#include <geos/simplify/DouglasPeuckerLineSimplifier.h>
-#include <geos/geom/Geometry.h> // for AutoPtr typedefs
+#include <geos/geom/Geometry.h> // for Ptr typedefs
#include <geos/geom/MultiPolygon.h>
-#include <geos/geom/CoordinateSequence.h> // for AutoPtr typedefs
+#include <geos/geom/CoordinateSequence.h> // for Ptr typedefs
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/CoordinateSequenceFactory.h>
#include <geos/geom/util/GeometryTransformer.h> // for DPTransformer inheritance
#include <geos/util/IllegalArgumentException.h>
#include <geos/util.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cassert>
#ifndef GEOS_DEBUG
@@ -51,15 +51,15 @@ public:
protected:
- CoordinateSequence::AutoPtr transformCoordinates(
+ CoordinateSequence::Ptr transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent);
- Geometry::AutoPtr transformPolygon(
+ Geometry::Ptr transformPolygon(
const Polygon* geom,
const Geometry* parent);
- Geometry::AutoPtr transformMultiPolygon(
+ Geometry::Ptr transformMultiPolygon(
const MultiPolygon* geom,
const Geometry* parent);
@@ -79,7 +79,7 @@ private:
* self-intersections
* @return a valid area geometry
*/
- Geometry::AutoPtr createValidArea(const Geometry* roughAreaGeom);
+ Geometry::Ptr createValidArea(const Geometry* roughAreaGeom);
double distanceTolerance;
@@ -92,13 +92,13 @@ DPTransformer::DPTransformer(double t)
setSkipTransformedInvalidInteriorRings(true);
}
-Geometry::AutoPtr
+Geometry::Ptr
DPTransformer::createValidArea(const Geometry* roughAreaGeom)
{
- return Geometry::AutoPtr(roughAreaGeom->buffer(0.0));
+ return Geometry::Ptr(roughAreaGeom->buffer(0.0));
}
-CoordinateSequence::AutoPtr
+CoordinateSequence::Ptr
DPTransformer::transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent)
@@ -108,17 +108,17 @@ DPTransformer::transformCoordinates(
const Coordinate::Vect* inputPts = coords->toVector();
assert(inputPts);
- std::auto_ptr<Coordinate::Vect> newPts =
+ std::unique_ptr<Coordinate::Vect> newPts =
DouglasPeuckerLineSimplifier::simplify(*inputPts,
distanceTolerance);
- return CoordinateSequence::AutoPtr(
+ return CoordinateSequence::Ptr(
factory->getCoordinateSequenceFactory()->create(
newPts.release()
));
}
-Geometry::AutoPtr
+Geometry::Ptr
DPTransformer::transformPolygon(
const Polygon* geom,
const Geometry* parent)
@@ -128,7 +128,7 @@ DPTransformer::transformPolygon(
std::cerr << "DPTransformer::transformPolygon(Polygon " << geom << ", Geometry " << parent << ");" << std::endl;
#endif
- Geometry::AutoPtr roughGeom(GeometryTransformer::transformPolygon(geom, parent));
+ Geometry::Ptr roughGeom(GeometryTransformer::transformPolygon(geom, parent));
// don't try and correct if the parent is going to do this
if ( dynamic_cast<const MultiPolygon*>(parent) )
@@ -139,7 +139,7 @@ DPTransformer::transformPolygon(
return createValidArea(roughGeom.get());
}
-Geometry::AutoPtr
+Geometry::Ptr
DPTransformer::transformMultiPolygon(
const MultiPolygon* geom,
const Geometry* parent)
@@ -147,7 +147,7 @@ DPTransformer::transformMultiPolygon(
#if GEOS_DEBUG
std::cerr << "DPTransformer::transformMultiPolygon(MultiPolygon " << geom << ", Geometry " << parent << ");" << std::endl;
#endif
- Geometry::AutoPtr roughGeom(GeometryTransformer::transformMultiPolygon(geom, parent));
+ Geometry::Ptr roughGeom(GeometryTransformer::transformMultiPolygon(geom, parent));
return createValidArea(roughGeom.get());
}
@@ -158,7 +158,7 @@ DPTransformer::transformMultiPolygon(
//DouglasPeuckerSimplifier::
/*public static*/
-Geometry::AutoPtr
+Geometry::Ptr
DouglasPeuckerSimplifier::simplify(const Geometry* geom,
double tolerance)
{
@@ -183,7 +183,7 @@ DouglasPeuckerSimplifier::setDistanceTolerance(double tol)
distanceTolerance = tol;
}
-Geometry::AutoPtr
+Geometry::Ptr
DouglasPeuckerSimplifier::getResultGeometry()
{
DPTransformer t(distanceTolerance);
diff --git a/src/simplify/LineSegmentIndex.cpp b/src/simplify/LineSegmentIndex.cpp
index 33184e1..9173d49 100644
--- a/src/simplify/LineSegmentIndex.cpp
+++ b/src/simplify/LineSegmentIndex.cpp
@@ -25,7 +25,7 @@
#include <geos/geom/Envelope.h>
#include <vector>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <cassert>
#ifndef GEOS_DEBUG
@@ -54,7 +54,7 @@ private:
const LineSegment* querySeg;
- auto_ptr< vector<LineSegment*> > items;
+ unique_ptr< vector<LineSegment*> > items;
public:
@@ -96,9 +96,10 @@ public:
}
}
- auto_ptr< vector<LineSegment*> > getItems()
+ unique_ptr< vector<LineSegment*> > getItems()
{
- return items;
+ // NOTE: Apparently, this is 'source' method giving up the object resource.
+ return std::move(items);
}
@@ -156,7 +157,7 @@ LineSegmentIndex::remove(const LineSegment* seg)
}
/*public*/
-auto_ptr< vector<LineSegment*> >
+unique_ptr< vector<LineSegment*> >
LineSegmentIndex::query(const LineSegment* querySeg) const
{
Envelope env(querySeg->p0, querySeg->p1);
@@ -164,7 +165,7 @@ LineSegmentIndex::query(const LineSegment* querySeg) const
LineSegmentVisitor visitor(querySeg);
index->query(&env, visitor);
- auto_ptr< vector<LineSegment*> > itemsFound = visitor.getItems();
+ unique_ptr< vector<LineSegment*> > itemsFound = visitor.getItems();
return itemsFound;
}
diff --git a/src/simplify/TaggedLineString.cpp b/src/simplify/TaggedLineString.cpp
index e39eb37..91f5d31 100644
--- a/src/simplify/TaggedLineString.cpp
+++ b/src/simplify/TaggedLineString.cpp
@@ -20,7 +20,7 @@
#include <geos/simplify/TaggedLineSegment.h>
#include <geos/geom/CoordinateSequence.h>
#include <geos/geom/LineString.h>
-#include <geos/geom/Geometry.h> // for auto_ptr destructor
+#include <geos/geom/Geometry.h> // for unique_ptr destructor
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/CoordinateSequenceFactory.h>
@@ -126,7 +126,7 @@ TaggedLineString::getParentCoordinates() const
}
/*public*/
-CoordinateSequence::AutoPtr
+CoordinateSequence::Ptr
TaggedLineString::getResultCoordinates() const
{
@@ -144,7 +144,7 @@ TaggedLineString::getResultCoordinates() const
CoordVect* v = pts.release();
- return CoordinateSequence::AutoPtr(parentLine->getFactory()->getCoordinateSequenceFactory()->create(v));
+ return CoordinateSequence::Ptr(parentLine->getFactory()->getCoordinateSequenceFactory()->create(v));
}
@@ -214,7 +214,7 @@ TaggedLineString::getSegments() const
}
/*public*/
-auto_ptr<Geometry>
+unique_ptr<Geometry>
TaggedLineString::asLineString() const
{
return parentLine->getFactory()->createLineString(
@@ -222,7 +222,7 @@ TaggedLineString::asLineString() const
}
/*public*/
-auto_ptr<Geometry>
+unique_ptr<Geometry>
TaggedLineString::asLinearRing() const
{
return parentLine->getFactory()->createLinearRing(
@@ -231,7 +231,7 @@ TaggedLineString::asLinearRing() const
/*public*/
void
-TaggedLineString::addToResult(auto_ptr<TaggedLineSegment> seg)
+TaggedLineString::addToResult(unique_ptr<TaggedLineSegment> seg)
{
#if GEOS_DEBUG
cerr << "TaggedLineString[" << this << "] adding "
diff --git a/src/simplify/TaggedLineStringSimplifier.cpp b/src/simplify/TaggedLineStringSimplifier.cpp
index 507c79f..ceaa50e 100644
--- a/src/simplify/TaggedLineStringSimplifier.cpp
+++ b/src/simplify/TaggedLineStringSimplifier.cpp
@@ -23,7 +23,7 @@
#include <geos/simplify/TaggedLineSegment.h>
#include <geos/geom/CoordinateSequence.h>
#include <geos/geom/LineString.h>
-//#include <geos/geom/Geometry.h> // for auto_ptr destructor
+//#include <geos/geom/Geometry.h> // for unique_ptr destructor
//#include <geos/geom/GeometryFactory.h>
//#include <geos/geom/CoordinateSequenceFactory.h>
@@ -103,11 +103,10 @@ TaggedLineStringSimplifier::simplifySection(std::size_t i,
std::cerr << "single segment, no flattening"
<< std::endl;
#endif
-
- auto_ptr<TaggedLineSegment> newSeg(new
+ unique_ptr<TaggedLineSegment> newSeg(new
TaggedLineSegment(*(line->getSegment(i))));
- line->addToResult(newSeg);
+ line->addToResult(std::move(newSeg));
// leave this segment in the input index, for efficiency
return;
}
@@ -155,7 +154,7 @@ TaggedLineStringSimplifier::simplifySection(std::size_t i,
if (isValidToSimplify)
{
- auto_ptr<TaggedLineSegment> newSeg = flatten(i, j);
+ unique_ptr<TaggedLineSegment> newSeg = flatten(i, j);
#if GEOS_DEBUG
std::cerr << "isValidToSimplify, adding seg "
@@ -164,7 +163,7 @@ TaggedLineStringSimplifier::simplifySection(std::size_t i,
<< std::endl;
#endif
- line->addToResult(newSeg);
+ line->addToResult(std::move(newSeg));
return;
}
@@ -175,13 +174,13 @@ TaggedLineStringSimplifier::simplifySection(std::size_t i,
/*private*/
-auto_ptr<TaggedLineSegment>
+unique_ptr<TaggedLineSegment>
TaggedLineStringSimplifier::flatten(std::size_t start, std::size_t end)
{
// make a new segment for the simplified geometry
const Coordinate& p0 = linePts->getAt(start);
const Coordinate& p1 = linePts->getAt(end);
- auto_ptr<TaggedLineSegment> newSeg(new TaggedLineSegment(p0, p1));
+ unique_ptr<TaggedLineSegment> newSeg(new TaggedLineSegment(p0, p1));
// update the indexes
remove(line, start, end);
outputIndex->add(newSeg.get());
@@ -209,7 +208,7 @@ bool
TaggedLineStringSimplifier::hasBadOutputIntersection(
const LineSegment& candidateSeg)
{
- auto_ptr< vector<LineSegment*> > querySegs =
+ unique_ptr< vector<LineSegment*> > querySegs =
outputIndex->query(&candidateSeg);
for (vector<LineSegment*>::iterator
@@ -245,7 +244,7 @@ TaggedLineStringSimplifier::hasBadInputIntersection(
const vector<std::size_t>& sectionIndex,
const LineSegment& candidateSeg)
{
- auto_ptr< vector<LineSegment*> > querySegs =
+ unique_ptr< vector<LineSegment*> > querySegs =
inputIndex->query(&candidateSeg);
for (vector<LineSegment*>::iterator
diff --git a/src/simplify/TopologyPreservingSimplifier.cpp b/src/simplify/TopologyPreservingSimplifier.cpp
index a669209..689c5e5 100644
--- a/src/simplify/TopologyPreservingSimplifier.cpp
+++ b/src/simplify/TopologyPreservingSimplifier.cpp
@@ -18,20 +18,20 @@
#include <geos/simplify/TopologyPreservingSimplifier.h>
#include <geos/simplify/TaggedLinesSimplifier.h>
-#include <geos/simplify/LineSegmentIndex.h> // for auto_ptr dtor
+#include <geos/simplify/LineSegmentIndex.h> // for unique_ptr dtor
#include <geos/simplify/TaggedLineString.h>
-#include <geos/simplify/TaggedLineStringSimplifier.h> // for auto_ptr dtor
-#include <geos/algorithm/LineIntersector.h> // for auto_ptr dtor
+#include <geos/simplify/TaggedLineStringSimplifier.h> // for unique_ptr dtor
+#include <geos/algorithm/LineIntersector.h> // for unique_ptr dtor
// for LineStringTransformer inheritance
#include <geos/geom/util/GeometryTransformer.h>
// for LineStringMapBuilderFilter inheritance
#include <geos/geom/GeometryComponentFilter.h>
-#include <geos/geom/Geometry.h> // for auto_ptr dtor
+#include <geos/geom/Geometry.h> // for unique_ptr dtor
#include <geos/geom/LineString.h>
#include <geos/geom/LinearRing.h>
#include <geos/util/IllegalArgumentException.h>
-#include <memory> // for auto_ptr
+#include <memory> // for unique_ptr
#include <map>
#include <cassert>
#include <iostream>
@@ -67,7 +67,7 @@ public:
protected:
- CoordinateSequence::AutoPtr transformCoordinates(
+ CoordinateSequence::Ptr transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent);
@@ -142,7 +142,7 @@ LineStringTransformer::LineStringTransformer(LinesMap& nMap)
}
/*protected*/
-CoordinateSequence::AutoPtr
+CoordinateSequence::Ptr
LineStringTransformer::transformCoordinates(
const CoordinateSequence* coords,
const Geometry* parent)
@@ -187,10 +187,7 @@ LineStringTransformer::transformCoordinates(
* This class populates the given LineString=>TaggedLineString map
* with newly created TaggedLineString objects.
* Users must take care of deleting the map's values (elem.second).
- * Would be nice if auto_ptr<> worked in a container, but it doesn't :(
- *
- * mloskot: So, let's write our own "shared smart pointer" or better ask
- * PCS about using Boost's shared_ptr.
+ * TODO: Consider container of unique_ptr
*
*/
class LineStringMapBuilderFilter: public geom::GeometryComponentFilter
@@ -263,7 +260,7 @@ LineStringMapBuilderFilter::filter_ro(const Geometry* geom)
} // end of module-statics
/*public static*/
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
TopologyPreservingSimplifier::simplify(
const geom::Geometry* geom,
double tolerance)
@@ -295,16 +292,16 @@ TopologyPreservingSimplifier::setDistanceTolerance(double d)
/*public*/
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
TopologyPreservingSimplifier::getResultGeometry()
{
// empty input produces an empty result
- if (inputGeom->isEmpty()) return std::auto_ptr<Geometry>(inputGeom->clone());
+ if (inputGeom->isEmpty()) return std::unique_ptr<Geometry>(inputGeom->clone());
LinesMap linestringMap;
- std::auto_ptr<geom::Geometry> result;
+ std::unique_ptr<geom::Geometry> result;
try {
LineStringMapBuilderFilter lsmbf(linestringMap);
diff --git a/src/triangulate/DelaunayTriangulationBuilder.cpp b/src/triangulate/DelaunayTriangulationBuilder.cpp
index 35291df..fff47be 100644
--- a/src/triangulate/DelaunayTriangulationBuilder.cpp
+++ b/src/triangulate/DelaunayTriangulationBuilder.cpp
@@ -118,7 +118,7 @@ DelaunayTriangulationBuilder::getSubdivision()
return *subdiv;
}
-std::auto_ptr<MultiLineString>
+std::unique_ptr<MultiLineString>
DelaunayTriangulationBuilder::getEdges(
const GeometryFactory& geomFact)
{
@@ -126,7 +126,7 @@ DelaunayTriangulationBuilder::getEdges(
return subdiv->getEdges(geomFact);
}
-std::auto_ptr<geom::GeometryCollection>
+std::unique_ptr<geom::GeometryCollection>
DelaunayTriangulationBuilder::getTriangles(
const geom::GeometryFactory& geomFact)
{
diff --git a/src/triangulate/VoronoiDiagramBuilder.cpp b/src/triangulate/VoronoiDiagramBuilder.cpp
index 8cfbb4e..b9ea42b 100644
--- a/src/triangulate/VoronoiDiagramBuilder.cpp
+++ b/src/triangulate/VoronoiDiagramBuilder.cpp
@@ -83,7 +83,7 @@ VoronoiDiagramBuilder::create()
if(clipEnv)
diagramEnv.expandToInclude(clipEnv);
- std::auto_ptr<IncrementalDelaunayTriangulator::VertexList> vertices (
+ std::unique_ptr<IncrementalDelaunayTriangulator::VertexList> vertices (
DelaunayTriangulationBuilder::toVertices(*siteCoords)
);
@@ -92,41 +92,42 @@ VoronoiDiagramBuilder::create()
triangulator.insertSites(*vertices);
}
-std::auto_ptr<quadedge::QuadEdgeSubdivision>
+std::unique_ptr<quadedge::QuadEdgeSubdivision>
VoronoiDiagramBuilder::getSubdivision()
{
create();
- return subdiv;
+ // NOTE: Apparently, this is 'source' method giving up the object resource.
+ return std::move(subdiv);
}
-std::auto_ptr<geom::GeometryCollection>
+std::unique_ptr<geom::GeometryCollection>
VoronoiDiagramBuilder::getDiagram(const geom::GeometryFactory& geomFact)
{
create();
- std::auto_ptr<geom::GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
+ std::unique_ptr<geom::GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
return clipGeometryCollection(*polys,diagramEnv);
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
VoronoiDiagramBuilder::getDiagramEdges(const geom::GeometryFactory& geomFact)
{
create();
- std::auto_ptr<geom::MultiLineString> edges = subdiv->getVoronoiDiagramEdges(geomFact);
- if ( edges->isEmpty() ) return std::auto_ptr<Geometry>(edges.release());
- std::auto_ptr<geom::Geometry> clipPoly ( geomFact.toGeometry(&diagramEnv) );
- std::auto_ptr<Geometry> clipped( clipPoly->intersection(edges.get()) );
+ std::unique_ptr<geom::MultiLineString> edges = subdiv->getVoronoiDiagramEdges(geomFact);
+ if ( edges->isEmpty() ) return std::unique_ptr<Geometry>(edges.release());
+ std::unique_ptr<geom::Geometry> clipPoly ( geomFact.toGeometry(&diagramEnv) );
+ std::unique_ptr<Geometry> clipped( clipPoly->intersection(edges.get()) );
return clipped;
}
-std::auto_ptr<geom::GeometryCollection>
+std::unique_ptr<geom::GeometryCollection>
VoronoiDiagramBuilder::clipGeometryCollection(const geom::GeometryCollection& geom, const geom::Envelope& clipEnv)
{
- std::auto_ptr<geom::Geometry> clipPoly ( geom.getFactory()->toGeometry(&clipEnv) );
- std::auto_ptr< std::vector<Geometry*> >clipped(new std::vector<Geometry*>);
+ std::unique_ptr<geom::Geometry> clipPoly ( geom.getFactory()->toGeometry(&clipEnv) );
+ std::unique_ptr< std::vector<Geometry*> >clipped(new std::vector<Geometry*>);
for(std::size_t i=0 ; i < geom.getNumGeometries() ; i++)
{
const Geometry* g = geom.getGeometryN(i);
- std::auto_ptr<Geometry> result;
+ std::unique_ptr<Geometry> result;
// don't clip unless necessary
if(clipEnv.contains(g->getEnvelopeInternal()))
{
@@ -144,7 +145,7 @@ VoronoiDiagramBuilder::clipGeometryCollection(const geom::GeometryCollection& ge
clipped->push_back(result.release());
}
}
- return std::auto_ptr<GeometryCollection>(geom.getFactory()->createGeometryCollection(clipped.release()));
+ return std::unique_ptr<GeometryCollection>(geom.getFactory()->createGeometryCollection(clipped.release()));
}
} //namespace geos.triangulate
diff --git a/src/triangulate/quadedge/QuadEdge.cpp b/src/triangulate/quadedge/QuadEdge.cpp
index 4a4e63a..82929ff 100644
--- a/src/triangulate/quadedge/QuadEdge.cpp
+++ b/src/triangulate/quadedge/QuadEdge.cpp
@@ -24,7 +24,7 @@ namespace quadedge { //geos.triangulate.quadedge
using namespace geos::geom;
-std::auto_ptr<QuadEdge>
+std::unique_ptr<QuadEdge>
QuadEdge::makeEdge(const Vertex &o, const Vertex &d)
{
QuadEdge *q0 = new QuadEdge();
@@ -47,13 +47,13 @@ QuadEdge::makeEdge(const Vertex &o, const Vertex &d)
base->setOrig(o);
base->setDest(d);
- return std::auto_ptr<QuadEdge>(base);
+ return std::unique_ptr<QuadEdge>(base);
}
-std::auto_ptr<QuadEdge>
+std::unique_ptr<QuadEdge>
QuadEdge::connect(QuadEdge &a, QuadEdge &b)
{
- std::auto_ptr<QuadEdge> q0 = makeEdge(a.dest(), b.orig());
+ std::unique_ptr<QuadEdge> q0 = makeEdge(a.dest(), b.orig());
splice(*q0, a.lNext());
splice(q0->sym(), b);
return q0;
@@ -165,10 +165,10 @@ QuadEdge::equalsOriented(const QuadEdge &qe) const
return false;
}
-std::auto_ptr<LineSegment>
+std::unique_ptr<LineSegment>
QuadEdge::toLineSegment() const
{
- return std::auto_ptr<geom::LineSegment>(
+ return std::unique_ptr<geom::LineSegment>(
new geom::LineSegment(vertex.getCoordinate(), dest().getCoordinate()));
}
diff --git a/src/triangulate/quadedge/QuadEdgeSubdivision.cpp b/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
index 8e58ee0..cd227b4 100644
--- a/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
+++ b/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
@@ -109,22 +109,22 @@ QuadEdgeSubdivision::createFrame(const geom::Envelope &env)
void
QuadEdgeSubdivision::initSubdiv(QuadEdge* initEdges[3])
{
- std::auto_ptr<QuadEdge> tmp_auto_ptr;
+ std::unique_ptr<QuadEdge> tmp_ptr;
// build initial subdivision from frame
- tmp_auto_ptr = QuadEdge::makeEdge(frameVertex[0], frameVertex[1]);
- initEdges[0] = tmp_auto_ptr.get();
- tmp_auto_ptr.release();
+ tmp_ptr = QuadEdge::makeEdge(frameVertex[0], frameVertex[1]);
+ initEdges[0] = tmp_ptr.get();
+ tmp_ptr.release();
- tmp_auto_ptr = QuadEdge::makeEdge(frameVertex[1], frameVertex[2]);
- initEdges[1] = tmp_auto_ptr.get();
- tmp_auto_ptr.release();
+ tmp_ptr = QuadEdge::makeEdge(frameVertex[1], frameVertex[2]);
+ initEdges[1] = tmp_ptr.get();
+ tmp_ptr.release();
QuadEdge::splice(initEdges[0]->sym(), *initEdges[1]);
- tmp_auto_ptr = QuadEdge::makeEdge(frameVertex[2], frameVertex[0]);
- initEdges[2] = tmp_auto_ptr.get();
- tmp_auto_ptr.release();
+ tmp_ptr = QuadEdge::makeEdge(frameVertex[2], frameVertex[0]);
+ initEdges[2] = tmp_ptr.get();
+ tmp_ptr.release();
QuadEdge::splice(initEdges[1]->sym(), *initEdges[2]);
QuadEdge::splice(initEdges[2]->sym(), *initEdges[0]);
@@ -133,7 +133,7 @@ QuadEdgeSubdivision::initSubdiv(QuadEdge* initEdges[3])
QuadEdge&
QuadEdgeSubdivision::makeEdge(const Vertex &o, const Vertex &d)
{
- std::auto_ptr<QuadEdge> q0 = QuadEdge::makeEdge(o, d);
+ std::unique_ptr<QuadEdge> q0 = QuadEdge::makeEdge(o, d);
QuadEdge *q0_ptr = q0.get();
q0.release();
@@ -145,7 +145,7 @@ QuadEdgeSubdivision::makeEdge(const Vertex &o, const Vertex &d)
QuadEdge&
QuadEdgeSubdivision::connect(QuadEdge &a, QuadEdge &b)
{
- std::auto_ptr<QuadEdge> q0 = QuadEdge::connect(a, b);
+ std::unique_ptr<QuadEdge> q0 = QuadEdge::connect(a, b);
QuadEdge *q0_ptr = q0.get();
q0.release();
@@ -310,7 +310,7 @@ QuadEdgeSubdivision::isVertexOfEdge(const QuadEdge &e, const Vertex &v) const
return false;
}
-std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList>
+std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList>
QuadEdgeSubdivision::getPrimaryEdges(bool includeFrame)
{
QuadEdgeList *edges = new QuadEdgeList();
@@ -337,7 +337,7 @@ QuadEdgeSubdivision::getPrimaryEdges(bool includeFrame)
visitedEdges.insert(&edge->sym());
}
}
- return std::auto_ptr<QuadEdgeList>(edges);
+ return std::unique_ptr<QuadEdgeList>(edges);
}
QuadEdge**
@@ -444,10 +444,10 @@ QuadEdgeSubdivision::visitTriangles(TriangleVisitor *triVisitor, bool includeFra
}
}
-std::auto_ptr<geom::MultiLineString>
+std::unique_ptr<geom::MultiLineString>
QuadEdgeSubdivision::getEdges(const geom::GeometryFactory& geomFact)
{
- std::auto_ptr<QuadEdgeList> quadEdges(getPrimaryEdges(false));
+ std::unique_ptr<QuadEdgeList> quadEdges(getPrimaryEdges(false));
std::vector<Geometry *> edges(quadEdges->size());
const CoordinateSequenceFactory *coordSeqFact = geomFact.getCoordinateSequenceFactory();
int i = 0;
@@ -469,10 +469,10 @@ QuadEdgeSubdivision::getEdges(const geom::GeometryFactory& geomFact)
for(std::vector<Geometry*>::iterator it=edges.begin(); it!=edges.end(); ++it)
delete *it;
- return std::auto_ptr<MultiLineString>(result);
+ return std::unique_ptr<MultiLineString>(result);
}
-std::auto_ptr<GeometryCollection>
+std::unique_ptr<GeometryCollection>
QuadEdgeSubdivision::getTriangles( const GeometryFactory &geomFact)
{
TriList triPtsList;
@@ -494,38 +494,38 @@ QuadEdgeSubdivision::getTriangles( const GeometryFactory &geomFact)
delete *it;
tris.clear();
- return std::auto_ptr<GeometryCollection>(ret);
+ return std::unique_ptr<GeometryCollection>(ret);
}
//Methods for VoronoiDiagram
-std::auto_ptr<geom::GeometryCollection>
+std::unique_ptr<geom::GeometryCollection>
QuadEdgeSubdivision::getVoronoiDiagram(const geom::GeometryFactory& geomFact)
{
- std::auto_ptr< std::vector<geom::Geometry*> > vorCells = getVoronoiCellPolygons(geomFact);
- return std::auto_ptr<GeometryCollection>(geomFact.createGeometryCollection(vorCells.release()));
+ std::unique_ptr< std::vector<geom::Geometry*> > vorCells = getVoronoiCellPolygons(geomFact);
+ return std::unique_ptr<GeometryCollection>(geomFact.createGeometryCollection(vorCells.release()));
}
-std::auto_ptr<geom::MultiLineString>
+std::unique_ptr<geom::MultiLineString>
QuadEdgeSubdivision::getVoronoiDiagramEdges(const geom::GeometryFactory& geomFact)
{
- std::auto_ptr< std::vector<geom::Geometry*> > vorCells = getVoronoiCellEdges(geomFact);
- return std::auto_ptr<MultiLineString>(geomFact.createMultiLineString(vorCells.release()));
+ std::unique_ptr< std::vector<geom::Geometry*> > vorCells = getVoronoiCellEdges(geomFact);
+ return std::unique_ptr<MultiLineString>(geomFact.createMultiLineString(vorCells.release()));
}
-std::auto_ptr< std::vector<geom::Geometry*> >
+std::unique_ptr< std::vector<geom::Geometry*> >
QuadEdgeSubdivision::getVoronoiCellPolygons(const geom::GeometryFactory& geomFact)
{
- std::auto_ptr< std::vector<geom::Geometry*> > cells(new std::vector<geom::Geometry*>);
+ std::unique_ptr< std::vector<geom::Geometry*> > cells(new std::vector<geom::Geometry*>);
TriangleCircumcentreVisitor* tricircumVisitor = new TriangleCircumcentreVisitor();
visitTriangles((TriangleVisitor*)tricircumVisitor, true);
- std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList> edges = getVertexUniqueEdges(false);
+ std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList> edges = getVertexUniqueEdges(false);
for(QuadEdgeSubdivision::QuadEdgeList::iterator it=edges->begin() ; it!=edges->end() ; ++it)
{
QuadEdge *qe = *it;
- std::auto_ptr<geom::Geometry> poly = getVoronoiCellPolygon(qe,geomFact);
+ std::unique_ptr<geom::Geometry> poly = getVoronoiCellPolygon(qe,geomFact);
cells->push_back(poly.release());
}
@@ -533,19 +533,19 @@ QuadEdgeSubdivision::getVoronoiCellPolygons(const geom::GeometryFactory& geomFac
return cells;
}
-std::auto_ptr< std::vector<geom::Geometry*> >
+std::unique_ptr< std::vector<geom::Geometry*> >
QuadEdgeSubdivision::getVoronoiCellEdges(const geom::GeometryFactory& geomFact)
{
- std::auto_ptr< std::vector<geom::Geometry*> > cells(new std::vector<geom::Geometry*>);
+ std::unique_ptr< std::vector<geom::Geometry*> > cells(new std::vector<geom::Geometry*>);
TriangleCircumcentreVisitor* tricircumVisitor = new TriangleCircumcentreVisitor();
visitTriangles((TriangleVisitor*)tricircumVisitor, true);
- std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList> edges = getVertexUniqueEdges(false);
+ std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList> edges = getVertexUniqueEdges(false);
for(QuadEdgeSubdivision::QuadEdgeList::iterator it=edges->begin() ; it!=edges->end() ; ++it)
{
QuadEdge *qe = *it;
- std::auto_ptr<geom::Geometry> poly = getVoronoiCellEdge(qe,geomFact);
+ std::unique_ptr<geom::Geometry> poly = getVoronoiCellEdge(qe,geomFact);
cells->push_back(poly.release());
}
@@ -553,7 +553,7 @@ QuadEdgeSubdivision::getVoronoiCellEdges(const geom::GeometryFactory& geomFact)
return cells;
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
QuadEdgeSubdivision::getVoronoiCellPolygon(QuadEdge* qe ,const geom::GeometryFactory& geomFact)
{
std::vector<Coordinate> cellPts;
@@ -577,8 +577,8 @@ QuadEdgeSubdivision::getVoronoiCellPolygon(QuadEdge* qe ,const geom::GeometryFac
coordList.insert(coordList.end(),*(coordList.end()),true);
}
- std::auto_ptr<Coordinate::Vect> pts = coordList.toCoordinateArray();
- std::auto_ptr<geom::Geometry> cellPoly(
+ std::unique_ptr<Coordinate::Vect> pts = coordList.toCoordinateArray();
+ std::unique_ptr<geom::Geometry> cellPoly(
geomFact.createPolygon(geomFact.createLinearRing(new geom::CoordinateArraySequence(pts.release())),NULL));
Vertex v = startQE->orig();
@@ -588,7 +588,7 @@ QuadEdgeSubdivision::getVoronoiCellPolygon(QuadEdge* qe ,const geom::GeometryFac
return cellPoly;
}
-std::auto_ptr<geom::Geometry>
+std::unique_ptr<geom::Geometry>
QuadEdgeSubdivision::getVoronoiCellEdge(QuadEdge* qe ,const geom::GeometryFactory& geomFact)
{
std::vector<Coordinate> cellPts;
@@ -607,8 +607,8 @@ QuadEdgeSubdivision::getVoronoiCellEdge(QuadEdge* qe ,const geom::GeometryFactor
//for checking close ring in CoordList class:
coordList.closeRing();
- std::auto_ptr<Coordinate::Vect> pts = coordList.toCoordinateArray();
- std::auto_ptr<geom::Geometry> cellEdge(
+ std::unique_ptr<Coordinate::Vect> pts = coordList.toCoordinateArray();
+ std::unique_ptr<geom::Geometry> cellEdge(
geomFact.createLineString(new geom::CoordinateArraySequence(pts.release())));
Vertex v = startQE->orig();
@@ -618,10 +618,10 @@ QuadEdgeSubdivision::getVoronoiCellEdge(QuadEdge* qe ,const geom::GeometryFactor
return cellEdge;
}
-std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList>
+std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList>
QuadEdgeSubdivision::getVertexUniqueEdges(bool includeFrame)
{
- std::auto_ptr<QuadEdgeSubdivision::QuadEdgeList> edges(new QuadEdgeList());
+ std::unique_ptr<QuadEdgeSubdivision::QuadEdgeList> edges(new QuadEdgeList());
std::set<Vertex> visitedVertices;
for(QuadEdgeSubdivision::QuadEdgeList::iterator it=quadEdges.begin() ; it!=quadEdges.end() ; ++it)
{
diff --git a/src/triangulate/quadedge/Vertex.cpp b/src/triangulate/quadedge/Vertex.cpp
index c286e60..04287f7 100644
--- a/src/triangulate/quadedge/Vertex.cpp
+++ b/src/triangulate/quadedge/Vertex.cpp
@@ -48,8 +48,8 @@ Vertex::Vertex() : p() {
int Vertex::classify(const Vertex &p0, const Vertex &p1)
{
Vertex &p2 = *this;
- std::auto_ptr<Vertex> a = p1.sub(p0);
- std::auto_ptr<Vertex> b = p2.sub(p0);
+ std::unique_ptr<Vertex> a = p1.sub(p0);
+ std::unique_ptr<Vertex> b = p2.sub(p0);
double sa = a->crossProduct(*b);
if (sa > 0.0)
@@ -83,7 +83,7 @@ bool Vertex::leftOf(const QuadEdge &e) const {
return isCCW(e.orig(), e.dest());
}
-std::auto_ptr<HCoordinate> Vertex::bisector(const Vertex &a, const Vertex &b)
+std::unique_ptr<HCoordinate> Vertex::bisector(const Vertex &a, const Vertex &b)
{
// returns the perpendicular bisector of the line segment ab
double dx = b.getX() - a.getX();
@@ -91,12 +91,12 @@ std::auto_ptr<HCoordinate> Vertex::bisector(const Vertex &a, const Vertex &b)
HCoordinate l1 = HCoordinate(a.getX() + dx / 2.0, a.getY() + dy / 2.0, 1.0);
HCoordinate l2 = HCoordinate(a.getX() - dy + dx / 2.0, a.getY() + dx + dy / 2.0, 1.0);
- return std::auto_ptr<HCoordinate>(new HCoordinate(l1, l2));
+ return std::unique_ptr<HCoordinate>(new HCoordinate(l1, l2));
}
double Vertex::circumRadiusRatio(const Vertex &b, const Vertex &c)
{
- std::auto_ptr<Vertex> x(circleCenter(b, c));
+ std::unique_ptr<Vertex> x(circleCenter(b, c));
double radius = distance(*x, b);
double edgeLength = distance(*this, b);
double el = distance(b, c);
@@ -113,24 +113,24 @@ double Vertex::circumRadiusRatio(const Vertex &b, const Vertex &c)
return radius / edgeLength;
}
-std::auto_ptr<Vertex> Vertex::midPoint(const Vertex &a)
+std::unique_ptr<Vertex> Vertex::midPoint(const Vertex &a)
{
double xm = (p.x + a.getX()) / 2.0;
double ym = (p.y + a.getY()) / 2.0;
double zm = (p.z + a.getZ()) / 2.0;
- return std::auto_ptr<Vertex>(new Vertex(xm, ym, zm));
+ return std::unique_ptr<Vertex>(new Vertex(xm, ym, zm));
}
-std::auto_ptr<Vertex> Vertex::circleCenter(const Vertex &b, const Vertex &c) const
+std::unique_ptr<Vertex> Vertex::circleCenter(const Vertex &b, const Vertex &c) const
{
- std::auto_ptr<Vertex> a(new Vertex(getX(), getY()));
+ std::unique_ptr<Vertex> a(new Vertex(getX(), getY()));
// compute the perpendicular bisector of cord ab
- std::auto_ptr<HCoordinate> cab = bisector(*a, b);
+ std::unique_ptr<HCoordinate> cab = bisector(*a, b);
// compute the perpendicular bisector of cord bc
- std::auto_ptr<HCoordinate> cbc = bisector(b, c);
+ std::unique_ptr<HCoordinate> cbc = bisector(b, c);
// compute the intersection of the bisectors (circle radii)
- std::auto_ptr<HCoordinate> hcc(new HCoordinate(*cab, *cbc));
- std::auto_ptr<Vertex> cc;
+ std::unique_ptr<HCoordinate> hcc(new HCoordinate(*cab, *cbc));
+ std::unique_ptr<Vertex> cc;
try
{
diff --git a/src/util/GeometricShapeFactory.cpp b/src/util/GeometricShapeFactory.cpp
index 26f317c..5d1e67c 100644
--- a/src/util/GeometricShapeFactory.cpp
+++ b/src/util/GeometricShapeFactory.cpp
@@ -89,7 +89,7 @@ GeometricShapeFactory::createRectangle()
int ipt = 0;
int nSide = nPts / 4;
if (nSide < 1) nSide = 1;
- std::auto_ptr<Envelope> env ( dim.getEnvelope() );
+ std::unique_ptr<Envelope> env ( dim.getEnvelope() );
double XsegLen = env->getWidth() / nSide;
double YsegLen = env->getHeight() / nSide;
@@ -126,7 +126,7 @@ GeometricShapeFactory::createRectangle()
Polygon*
GeometricShapeFactory::createCircle()
{
- std::auto_ptr<Envelope> env ( dim.getEnvelope() );
+ std::unique_ptr<Envelope> env ( dim.getEnvelope() );
double xRadius = env->getWidth() / 2.0;
double yRadius = env->getHeight() / 2.0;
@@ -152,7 +152,7 @@ GeometricShapeFactory::createCircle()
LineString*
GeometricShapeFactory::createArc(double startAng, double angExtent)
{
- std::auto_ptr<Envelope> env ( dim.getEnvelope() );
+ std::unique_ptr<Envelope> env ( dim.getEnvelope() );
double xRadius = env->getWidth() / 2.0;
double yRadius = env->getHeight() / 2.0;
@@ -181,7 +181,7 @@ GeometricShapeFactory::createArc(double startAng, double angExtent)
Polygon*
GeometricShapeFactory::createArcPolygon(double startAng, double angExtent)
{
- std::auto_ptr<Envelope> env ( dim.getEnvelope() );
+ std::unique_ptr<Envelope> env ( dim.getEnvelope() );
double xRadius = env->getWidth() / 2.0;
double yRadius = env->getHeight() / 2.0;
diff --git a/tests/bigtest/TestSweepLineSpeed.cpp b/tests/bigtest/TestSweepLineSpeed.cpp
index 110d7ad..f4b02f0 100644
--- a/tests/bigtest/TestSweepLineSpeed.cpp
+++ b/tests/bigtest/TestSweepLineSpeed.cpp
@@ -53,7 +53,7 @@ void run(int nPts, GeometryFactory *fact) {
int main(int /* argc */, char** /* argv[] */) {
- GeometryFactory::unique_ptr factptr = GeometryFactory::create();
+ GeometryFactory::Ptr factptr = GeometryFactory::create();
GeometryFactory* fact = factptr.get();
run(1000,fact);
diff --git a/tests/bigtest/bug234.cpp b/tests/bigtest/bug234.cpp
index 4a7cfa3..6a2d0b1 100644
--- a/tests/bigtest/bug234.cpp
+++ b/tests/bigtest/bug234.cpp
@@ -12,7 +12,7 @@ using namespace geos::geom;
using namespace std;
int main() {
- GeometryFactory::unique_ptr factory = GeometryFactory::create();
+ GeometryFactory::Ptr factory = GeometryFactory::create();
vector< Geometry * > *polys1 = new vector<Geometry*>();
vector< Geometry * > *polys2 = new vector<Geometry*>();
diff --git a/tests/perf/operation/buffer/IteratedBufferStressTest.cpp b/tests/perf/operation/buffer/IteratedBufferStressTest.cpp
index ccb8b9f..e661e23 100644
--- a/tests/perf/operation/buffer/IteratedBufferStressTest.cpp
+++ b/tests/perf/operation/buffer/IteratedBufferStressTest.cpp
@@ -30,7 +30,7 @@ using namespace geos::geom;
using namespace geos::io;
using namespace std;
-typedef auto_ptr<Geometry> GeomPtr;
+typedef unique_ptr<Geometry> GeomPtr;
GeomPtr doBuffer(const Geometry& g, double dist)
{
diff --git a/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp b/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
index 0c62f1a..654e675 100644
--- a/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
+++ b/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
@@ -48,7 +48,7 @@ public:
{
double size = 100;
Coordinate origin(0, 0);
- auto_ptr<Geometry> sinePoly (
+ unique_ptr<Geometry> sinePoly (
createSineStar(origin, size, nPts)->getBoundary()
);
@@ -60,7 +60,7 @@ public:
using geos::precision::SimpleGeometryPrecisionReducer;
PrecisionModel pm(size/10);
SimpleGeometryPrecisionReducer reducer(&pm);
- auto_ptr<Geometry> sinePolyCrinkly ( reducer.reduce(sinePoly.get()) );
+ unique_ptr<Geometry> sinePolyCrinkly ( reducer.reduce(sinePoly.get()) );
sinePoly.reset();
Geometry& target = *sinePolyCrinkly;
@@ -128,7 +128,7 @@ private:
}
}
- auto_ptr<Polygon> createSineStar(const Coordinate& origin,
+ unique_ptr<Polygon> createSineStar(const Coordinate& origin,
double size, int nPts)
{
using geos::geom::util::SineStarFactory;
@@ -139,7 +139,7 @@ private:
gsf.setNumPoints(nPts);
gsf.setArmLengthRatio(2);
gsf.setNumArms(20);
- auto_ptr<Polygon> poly = gsf.createSineStar();
+ unique_ptr<Polygon> poly = gsf.createSineStar();
return poly;
}
diff --git a/tests/unit/algorithm/CGAlgorithms/computeOrientationTest.cpp b/tests/unit/algorithm/CGAlgorithms/computeOrientationTest.cpp
index e484563..ef557cb 100644
--- a/tests/unit/algorithm/CGAlgorithms/computeOrientationTest.cpp
+++ b/tests/unit/algorithm/CGAlgorithms/computeOrientationTest.cpp
@@ -46,9 +46,9 @@ namespace tut
void object::test<1>()
{
const std::string wkt("LINESTRING ( 0 0, 0 1, 1 1)");
- Geometry::AutoPtr geom(reader_.read(wkt));
+ Geometry::Ptr geom(reader_.read(wkt));
- CoordinateSequence::AutoPtr pts(geom->getCoordinates());
+ CoordinateSequence::Ptr pts(geom->getCoordinates());
int const a = CGAlgorithms::computeOrientation(pts->getAt(0), pts->getAt(1), pts->getAt(2));
int const b = CGAlgorithms::computeOrientation(pts->getAt(0), pts->getAt(1), pts->getAt(2));
diff --git a/tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp b/tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp
index 8d144cf..5ecbd54 100644
--- a/tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp
+++ b/tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp
@@ -28,7 +28,7 @@ namespace tut
struct test_isccw_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryPtr;
geos::geom::CoordinateSequence* cs_;
geos::io::WKTReader reader_;
diff --git a/tests/unit/algorithm/CGAlgorithms/isPointInRingTest.cpp b/tests/unit/algorithm/CGAlgorithms/isPointInRingTest.cpp
index f3922bf..4e5ea78 100644
--- a/tests/unit/algorithm/CGAlgorithms/isPointInRingTest.cpp
+++ b/tests/unit/algorithm/CGAlgorithms/isPointInRingTest.cpp
@@ -24,7 +24,7 @@ namespace tut
struct test_ispointinring_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
geos::geom::CoordinateSequence* cs_;
geos::io::WKTReader reader_;
diff --git a/tests/unit/algorithm/CGAlgorithms/signedAreaTest.cpp b/tests/unit/algorithm/CGAlgorithms/signedAreaTest.cpp
index 6834346..bbeaf38 100644
--- a/tests/unit/algorithm/CGAlgorithms/signedAreaTest.cpp
+++ b/tests/unit/algorithm/CGAlgorithms/signedAreaTest.cpp
@@ -27,7 +27,7 @@ namespace tut
struct test_signedarea_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryPtr;
geos::geom::CoordinateSequence* cs_;
geos::io::WKTReader reader_;
diff --git a/tests/unit/algorithm/ConvexHullTest.cpp b/tests/unit/algorithm/ConvexHullTest.cpp
index ede64d3..3ceed5f 100644
--- a/tests/unit/algorithm/ConvexHullTest.cpp
+++ b/tests/unit/algorithm/ConvexHullTest.cpp
@@ -36,14 +36,9 @@ namespace tut
// dummy data, not used
struct test_convexhull_data
{
- // Typedefs used as short names by test cases
- typedef std::auto_ptr<geos::geom::Geometry> GeometryAPtr;
- typedef std::auto_ptr<geos::geom::LineString> LineStringAPtr;
- typedef geos::geom::GeometryFactory GeometryFactory;
-
GeometryPtr geom_;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
test_convexhull_data()
@@ -75,12 +70,12 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr lineGeom(reader_.read("LINESTRING (30 220, 240 220, 240 220)"));
- LineStringAPtr line(dynamic_cast_auto_ptr<LineString>(lineGeom));
+ Geometry::Ptr lineGeom(reader_.read("LINESTRING (30 220, 240 220, 240 220)"));
+ LineString::Ptr line(dynamic_cast<LineString*>(lineGeom.release()));
ensure(0 != line.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (30 220, 240 220)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (30 220, 240 220)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = line->convexHull();
@@ -94,11 +89,11 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (130 240, 130 240, 130 240, 570 240, 570 240, 570 240, 650 240)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (130 240, 130 240, 130 240, 570 240, 570 240, 570 240, 650 240)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (130 240, 650 240)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (130 240, 650 240)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = geom->convexHull();
@@ -112,11 +107,11 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (0 0, 0 0, 10 0)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (0 0, 0 0, 10 0)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = geom->convexHull();
@@ -130,11 +125,11 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (0 0, 10 0, 10 0)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (0 0, 10 0, 10 0)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = geom->convexHull();
@@ -148,11 +143,11 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (0 0, 5 0, 10 0)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (0 0, 5 0, 10 0)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = geom->convexHull();
@@ -166,13 +161,13 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (0 0, 5 1, 10 0)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (0 0, 5 1, 10 0)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(geom->convexHull());
+ Geometry::Ptr hullGeom(geom->convexHull());
ensure(0 != hullGeom.get());
- GeometryAPtr expectedHull(reader_.read("POLYGON ((0 0, 5 1, 10 0, 0 0))"));
+ Geometry::Ptr expectedHull(reader_.read("POLYGON ((0 0, 5 1, 10 0, 0 0))"));
ensure(0 != expectedHull.get());
ensure_equals( hullGeom->toString(), expectedHull->toString() );
@@ -185,11 +180,11 @@ namespace tut
{
using geos::geom::LineString;
- GeometryAPtr geom(reader_.read("MULTIPOINT (0 0, 0 0, 5 0, 5 0, 10 0, 10 0)"));
+ Geometry::Ptr geom(reader_.read("MULTIPOINT (0 0, 0 0, 5 0, 5 0, 10 0, 10 0)"));
ensure(0 != geom.get());
- GeometryAPtr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
- LineStringAPtr convexHull(dynamic_cast_auto_ptr<LineString>(hullGeom));
+ Geometry::Ptr hullGeom(reader_.read("LINESTRING (0 0, 10 0)"));
+ LineString::Ptr convexHull(dynamic_cast<LineString*>(hullGeom.release()));
ensure(0 != convexHull.get());
geom_ = geom->convexHull();
diff --git a/tests/unit/algorithm/InteriorPointAreaTest.cpp b/tests/unit/algorithm/InteriorPointAreaTest.cpp
index 8445d6e..1542817 100644
--- a/tests/unit/algorithm/InteriorPointAreaTest.cpp
+++ b/tests/unit/algorithm/InteriorPointAreaTest.cpp
@@ -39,7 +39,7 @@ namespace tut
typedef geos::algorithm::InteriorPointArea InteriorPointArea;
geos::io::WKTReader reader;
- std::auto_ptr<Geometry> geom;
+ std::unique_ptr<Geometry> geom;
test_interiorpointarea_data()
{}
diff --git a/tests/unit/algorithm/MinimumDiameterTest.cpp b/tests/unit/algorithm/MinimumDiameterTest.cpp
index 8a339d3..9be920a 100644
--- a/tests/unit/algorithm/MinimumDiameterTest.cpp
+++ b/tests/unit/algorithm/MinimumDiameterTest.cpp
@@ -36,13 +36,13 @@ namespace tut
// dummy data, not used
struct test_minimumdiameter_data {
typedef geos::geom::Geometry Geometry;
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
typedef geos::geom::Coordinate Coordinate;
typedef geos::algorithm::MinimumDiameter MinimumDiameter;
geos::io::WKTReader reader;
- std::auto_ptr<Geometry> geom;
+ std::unique_ptr<Geometry> geom;
test_minimumdiameter_data()
{}
diff --git a/tests/unit/algorithm/PointLocatorTest.cpp b/tests/unit/algorithm/PointLocatorTest.cpp
index 82c02fa..25e0e28 100644
--- a/tests/unit/algorithm/PointLocatorTest.cpp
+++ b/tests/unit/algorithm/PointLocatorTest.cpp
@@ -8,7 +8,7 @@
#include <geos/algorithm/PointLocator.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/Coordinate.h>
// std
#include <sstream>
@@ -42,10 +42,10 @@ namespace tut
// for the same reason...
//
static PrecisionModel pm;
- static GeometryFactory::unique_ptr gf = GeometryFactory::create(&pm);
+ static GeometryFactory::Ptr gf = GeometryFactory::create(&pm);
static geos::io::WKTReader reader(gf.get());
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
void runPtLocator(int expected, const Coordinate& pt,
const std::string& wkt)
diff --git a/tests/unit/algorithm/RobustLineIntersectionTest.cpp b/tests/unit/algorithm/RobustLineIntersectionTest.cpp
index 95fb5d9..0937818 100644
--- a/tests/unit/algorithm/RobustLineIntersectionTest.cpp
+++ b/tests/unit/algorithm/RobustLineIntersectionTest.cpp
@@ -7,7 +7,7 @@
#include <geos/algorithm/LineIntersector.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/LineString.h>
#include <geos/geom/Coordinate.h>
// std
@@ -31,7 +31,7 @@ namespace tut
struct test_robustlineintersection_data
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
bool equals(const Coordinate& p0, const Coordinate& p1,
double distanceTolerance)
@@ -136,7 +136,7 @@ namespace tut
GeomPtr g(reader.read(expectedWKT));
- std::auto_ptr<CoordinateSequence> cs ( g->getCoordinates() );
+ std::unique_ptr<CoordinateSequence> cs ( g->getCoordinates() );
std::vector<Coordinate> intPt;
for (size_t i=0; i<cs->size(); ++i)
@@ -250,7 +250,7 @@ namespace tut
}
PrecisionModel pm;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
geos::io::WKTReader reader;
};
diff --git a/tests/unit/algorithm/RobustLineIntersectorTest.cpp b/tests/unit/algorithm/RobustLineIntersectorTest.cpp
index 68dd718..0f45798 100644
--- a/tests/unit/algorithm/RobustLineIntersectorTest.cpp
+++ b/tests/unit/algorithm/RobustLineIntersectorTest.cpp
@@ -9,7 +9,7 @@
#include <geos/algorithm/CGAlgorithms.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/LineString.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/Point.h>
@@ -34,7 +34,7 @@ namespace tut
struct test_robustlineintersector_data {
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
LineIntersector i;
@@ -238,7 +238,7 @@ namespace tut
using geos::geom::GeometryFactory;
using geos::geom::LineString;
- GeometryFactory::unique_ptr factory = GeometryFactory::create();
+ GeometryFactory::Ptr factory = GeometryFactory::create();
CoordinateSequence* cs = new CoordinateArraySequence();
cs->add(p1);
cs->add(p2);
@@ -300,7 +300,7 @@ namespace tut
{
using geos::geom::GeometryFactory;
geos::geom::PrecisionModel pm(1e+13);
- GeometryFactory::unique_ptr factory = GeometryFactory::create(&pm);
+ GeometryFactory::Ptr factory = GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
// POINT located between 3rd and 4th vertex of LINESTRING
diff --git a/tests/unit/algorithm/distance/DiscreteFrechetDistanceTest.cpp b/tests/unit/algorithm/distance/DiscreteFrechetDistanceTest.cpp
index 64a0e79..d4d55a2 100644
--- a/tests/unit/algorithm/distance/DiscreteFrechetDistanceTest.cpp
+++ b/tests/unit/algorithm/distance/DiscreteFrechetDistanceTest.cpp
@@ -9,7 +9,7 @@
#include <geos/algorithm/distance/DiscreteFrechetDistance.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/Coordinate.h>
// std
#include <cmath>
@@ -35,7 +35,7 @@ namespace tut
// Test data, not used
struct test_DiscreteFrechetDistance_data {
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
test_DiscreteFrechetDistance_data()
:
@@ -72,7 +72,7 @@ namespace tut
}
PrecisionModel pm;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
geos::io::WKTReader reader;
};
diff --git a/tests/unit/algorithm/distance/DiscreteHausdorffDistanceTest.cpp b/tests/unit/algorithm/distance/DiscreteHausdorffDistanceTest.cpp
index 695aa64..236ce39 100644
--- a/tests/unit/algorithm/distance/DiscreteHausdorffDistanceTest.cpp
+++ b/tests/unit/algorithm/distance/DiscreteHausdorffDistanceTest.cpp
@@ -10,7 +10,7 @@
#include <geos/algorithm/distance/DiscreteHausdorffDistance.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/Coordinate.h>
// std
#include <cmath>
@@ -36,7 +36,7 @@ namespace tut
// Test data, not used
struct test_DiscreteHausdorffDistance_data {
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
test_DiscreteHausdorffDistance_data()
:
@@ -73,7 +73,7 @@ namespace tut
}
PrecisionModel pm;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
geos::io::WKTReader reader;
};
diff --git a/tests/unit/capi/GEOSContainsTest.cpp b/tests/unit/capi/GEOSContainsTest.cpp
index f99056d..591cfb4 100644
--- a/tests/unit/capi/GEOSContainsTest.cpp
+++ b/tests/unit/capi/GEOSContainsTest.cpp
@@ -132,7 +132,7 @@ namespace tut
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -151,7 +151,7 @@ namespace tut
// A does NOT contain B if precision is extended to 1e+11 or beyond
{
geos::geom::PrecisionModel pm(1e+11);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -185,7 +185,7 @@ namespace tut
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -204,7 +204,7 @@ namespace tut
// A contains B if FLOATING PM is used with extended precision
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
diff --git a/tests/unit/capi/GEOSPreparedGeometryTest.cpp b/tests/unit/capi/GEOSPreparedGeometryTest.cpp
index 907af92..2308f7e 100644
--- a/tests/unit/capi/GEOSPreparedGeometryTest.cpp
+++ b/tests/unit/capi/GEOSPreparedGeometryTest.cpp
@@ -219,7 +219,7 @@ namespace tut
void object::test<8>()
{
geos::geom::PrecisionModel pm(1e+13);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
// POINT located between 3rd and 4th vertex of LINESTRING
@@ -271,7 +271,7 @@ namespace tut
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10); // NOTE: higher precision fails this test case
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -292,7 +292,7 @@ namespace tut
// A does NOT contain B if precision is extended to 1e+11 or beyond
{
geos::geom::PrecisionModel pm(1e+11);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -328,7 +328,7 @@ namespace tut
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10);
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
@@ -349,7 +349,7 @@ namespace tut
// A contains B if FLOATING PM is used with extended precision
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr factory = geos::geom::GeometryFactory::create(&pm);
+ geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
diff --git a/tests/unit/geom/CoordinateArraySequenceTest.cpp b/tests/unit/geom/CoordinateArraySequenceTest.cpp
index 9c1162e..4d4162c 100644
--- a/tests/unit/geom/CoordinateArraySequenceTest.cpp
+++ b/tests/unit/geom/CoordinateArraySequenceTest.cpp
@@ -541,7 +541,7 @@ namespace tut
typedef geos::geom::CoordinateSequenceFactory const* CoordinateFactoryCPtr;
CoordinateFactoryCPtr factory = geos::geom::CoordinateArraySequenceFactory::instance();
- std::auto_ptr<CoordinateSequence> sequence1ptr(factory->create(4, 2));
+ std::unique_ptr<CoordinateSequence> sequence1ptr(factory->create(4, 2));
CoordinateSequence& seq = *sequence1ptr;
// Index: 0 - Order: Y, X, Z
diff --git a/tests/unit/geom/CoordinateListTest.cpp b/tests/unit/geom/CoordinateListTest.cpp
index aedeb49..372d3a9 100644
--- a/tests/unit/geom/CoordinateListTest.cpp
+++ b/tests/unit/geom/CoordinateListTest.cpp
@@ -48,7 +48,7 @@ namespace tut
geos::geom::CoordinateList::iterator it, it2;
- std::auto_ptr< std::vector<Coordinate> > col( new std::vector<Coordinate>() );
+ std::unique_ptr< std::vector<Coordinate> > col( new std::vector<Coordinate>() );
col->push_back(a);
col->push_back(b);
col->push_back(c);
@@ -141,7 +141,7 @@ namespace tut
const Coordinate c(45,60);
const Coordinate d(100,0);
- std::auto_ptr< std::vector<Coordinate> > v( new std::vector<Coordinate>() );
+ std::unique_ptr< std::vector<Coordinate> > v( new std::vector<Coordinate>() );
v->push_back(a);
v->push_back(b);
v->push_back(c);
diff --git a/tests/unit/geom/Geometry/clone.cpp b/tests/unit/geom/Geometry/clone.cpp
index c5a5735..9fca572 100644
--- a/tests/unit/geom/Geometry/clone.cpp
+++ b/tests/unit/geom/Geometry/clone.cpp
@@ -20,9 +20,9 @@ namespace tut {
struct test_geometry_clone_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
- GeometryFactory::unique_ptr factory;
+ GeometryFactory::Ptr factory;
geos::io::WKTReader reader;
test_geometry_clone_data()
@@ -44,11 +44,11 @@ template<>
template<>
void object::test<1>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POINT (0 100)"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
@@ -60,11 +60,11 @@ template<>
template<>
void object::test<2>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"LINESTRING (0 0, 0 100, 100 100, 100 0)"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
@@ -76,11 +76,11 @@ template<>
template<>
void object::test<3>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
@@ -92,11 +92,11 @@ template<>
template<>
void object::test<4>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"MULTIPOINT (0 100, 5 6)"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
@@ -108,11 +108,11 @@ template<>
template<>
void object::test<5>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"MULTILINESTRING ((0 0, 0 100, 100 100, 100 0), (15 25, 25 52))"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
@@ -124,11 +124,11 @@ template<>
template<>
void object::test<6>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"MULTIPOLYGON (((0 0, 0 100, 100 100, 100 0, 0 0)))"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
ensure_equals( g1->getSRID(), g2->getSRID() );
@@ -138,11 +138,11 @@ template<>
template<>
void object::test<7>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"GEOMETRYCOLLECTION(MULTIPOLYGON (((0 0, 0 100, 100 100, 100 0, 0 0))),POINT(3 4))"
));
g1->setSRID(66);
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure( g1->equalsExact(g2.get()) );
ensure_equals( g1->getSRID(), 66 );
ensure_equals( g1->getSRID(), g2->getSRID() );
diff --git a/tests/unit/geom/Geometry/coversTest.cpp b/tests/unit/geom/Geometry/coversTest.cpp
index ea33b72..992800c 100644
--- a/tests/unit/geom/Geometry/coversTest.cpp
+++ b/tests/unit/geom/Geometry/coversTest.cpp
@@ -20,10 +20,10 @@ namespace tut {
struct test_contains_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
- geos::geom::GeometryFactory::unique_ptr factory;
+ geos::geom::GeometryFactory::Ptr factory;
geos::io::WKTReader reader;
test_contains_data()
@@ -46,10 +46,10 @@ template<>
template<>
void object::test<1>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POLYGON ((0 0, 0 100, 90 90, 90 0, 0 0))"
));
@@ -63,10 +63,10 @@ template<>
template<>
void object::test<2>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"LINESTRING (0 0, 0 100)"
));
@@ -81,10 +81,10 @@ template<>
template<>
void object::test<3>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"LINESTRING (0 0, 0 100)"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT(0 0)"
));
@@ -107,10 +107,10 @@ template<>
template<>
void object::test<4>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POLYGON ((-1.183864 52.951915, -1.183862 52.951903, -1.183890 52.951900, -1.183924 52.951897, -1.183958 52.951894, -1.183954 52.951880, -1.183954 52.951878, -1.183932 52.951841, -1.183904 52.951844, -1.183870 52.951847, -1.183832 52.951852, -1.183824 52.951838, -1.183820 52.951830, -1.183870 52.951819, -1.183886 52.951815, -1.183890 52.951819, -1.183929 52.951810, -1.183909 52.951776, -1.183861 52.951787, -1.183853 52.951788, -1.183842 52.951770, -1.183970 52.951742, -1.183983 52.951763, -1.183963 52.951768, -1.183975 52.951788, -1.183994 52.951785, -1.184009 52.951807, -1.184002 52.951808, -1.184009 52.951835, -1.183990 52.951836, -1.183990 52.951836, -1.183990 52.951838, -1.184001 52.951880, -1.184018 52.951954, -1.184020 52.951956, -1.183998 52.951957, -1.183998 52.951956, -1.183996 52.951948, -1.183970 52.951906, -1.183936 52.951909, -1.183864 52.951915))"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT (-1.183972 52.951871)"
));
diff --git a/tests/unit/geom/Geometry/equalsTest.cpp b/tests/unit/geom/Geometry/equalsTest.cpp
index 78c3943..a060767 100644
--- a/tests/unit/geom/Geometry/equalsTest.cpp
+++ b/tests/unit/geom/Geometry/equalsTest.cpp
@@ -20,7 +20,7 @@ namespace tut {
struct test_equals_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
geos::io::WKTReader reader;
test_equals_data()
@@ -42,19 +42,19 @@ group test_equals_data("geos::geom::Geometry::equals");
template<> template<> void object::test<1>() {
- GeomAutoPtr g1(reader.read("POINT EMPTY"));
+ GeomPtr g1(reader.read("POINT EMPTY"));
ensure( g1->equals(g1.get()) );
- GeomAutoPtr g2(reader.read("LINESTRING EMPTY"));
+ GeomPtr g2(reader.read("LINESTRING EMPTY"));
ensure( g2->equals(g2.get()) );
ensure( g2->equals(g1.get()) );
- GeomAutoPtr g3(reader.read("POLYGON EMPTY"));
+ GeomPtr g3(reader.read("POLYGON EMPTY"));
ensure( g3->equals(g3.get()) );
ensure( g3->equals(g2.get()) );
ensure( g3->equals(g1.get()) );
- GeomAutoPtr g4(reader.read("GEOMETRYCOLLECTION EMPTY"));
+ GeomPtr g4(reader.read("GEOMETRYCOLLECTION EMPTY"));
ensure( g4->equals(g4.get()) );
ensure( g4->equals(g3.get()) );
ensure( g4->equals(g2.get()) );
diff --git a/tests/unit/geom/Geometry/normalize.cpp b/tests/unit/geom/Geometry/normalize.cpp
index d25f236..05668c4 100644
--- a/tests/unit/geom/Geometry/normalize.cpp
+++ b/tests/unit/geom/Geometry/normalize.cpp
@@ -21,7 +21,7 @@ namespace tut {
struct test_geometry_normalize_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
geos::io::WKTReader reader;
geos::io::WKTWriter writer;
@@ -34,13 +34,13 @@ struct test_geometry_normalize_data
void
runTest(const char *from, const char *exp)
{
- GeomAutoPtr g1(reader.read(from));
+ GeomPtr g1(reader.read(from));
ensure(g1.get());
- GeomAutoPtr g2(g1->clone());
+ GeomPtr g2(g1->clone());
ensure(g2.get());
g2->normalize();
- GeomAutoPtr ge(reader.read(exp));
+ GeomPtr ge(reader.read(exp));
bool eq = g2->equalsExact(ge.get());
if ( ! eq ) {
using namespace std;
diff --git a/tests/unit/geom/Geometry/touchesTest.cpp b/tests/unit/geom/Geometry/touchesTest.cpp
index f566fba..ee65382 100644
--- a/tests/unit/geom/Geometry/touchesTest.cpp
+++ b/tests/unit/geom/Geometry/touchesTest.cpp
@@ -20,10 +20,10 @@ namespace tut {
struct test_touches_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
- geos::geom::GeometryFactory::unique_ptr factory;
+ geos::geom::GeometryFactory::Ptr factory;
geos::io::WKTReader reader;
geos::io::WKBReader breader;
@@ -48,11 +48,11 @@ template<>
template<>
void object::test<1>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"POINT (0 0)"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT (0 0)"
));
@@ -65,11 +65,11 @@ template<>
template<>
void object::test<2>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"LINESTRING(0 0, 1 1, 0 2)"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT (1 1)"
));
@@ -82,11 +82,11 @@ template<>
template<>
void object::test<3>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"LINESTRING(0 0, 1 1, 0 2)"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT (0 2)"
));
@@ -99,11 +99,11 @@ template<>
template<>
void object::test<4>()
{
- GeomAutoPtr g1(reader.read(
+ GeomPtr g1(reader.read(
"LINESTRING (-612844.96290006 279079.117329031,-257704.820935236 574364.179187424)"
));
- GeomAutoPtr g2(reader.read(
+ GeomPtr g2(reader.read(
"POINT (-257704.820935236 574364.179187424)"
));
@@ -120,8 +120,8 @@ void object::test<5>()
// B: LINESTRING(-2119.81532027122 4257.47493284327,-2119.81532027122 2326.7198668134)
std::stringstream wkbA("01020000000200000010efda91826fabc0a8e5329579a1b040008633595f6c8bc0a8e5329579a1b040");
std::stringstream wkbB("0102000000020000005999a871a18fa0c0a8e5329579a1b0405999a871a18fa0c0180a6292702da240");
- GeomAutoPtr a(breader.readHEX(wkbA));
- GeomAutoPtr b(breader.readHEX(wkbB));
+ GeomPtr a(breader.readHEX(wkbA));
+ GeomPtr b(breader.readHEX(wkbB));
ensure(a->touches(b.get()));
ensure(!a->disjoint(b.get()));
@@ -137,8 +137,8 @@ void object::test<6>()
// B: LINESTRING(1098.10978977856 4137.73818456235,1921.2999342099 2177.04893146225)
std::stringstream wkbA("010200000003000000603f483e8ac87ac092ba62a50373b1405851bb6c70289140b6d9a9f9bc29b04060a2990ed55799401226341da5a8b540");
std::stringstream wkbB("0102000000020000005851bb6c70289140b6d9a9f9bc29b040d019f42133059e40406c8b0d1902a140");
- GeomAutoPtr a(breader.readHEX(wkbA));
- GeomAutoPtr b(breader.readHEX(wkbB));
+ GeomPtr a(breader.readHEX(wkbA));
+ GeomPtr b(breader.readHEX(wkbB));
ensure(a->touches(b.get()));
ensure(!a->disjoint(b.get()));
@@ -154,8 +154,8 @@ void object::test<7>()
// B: LINESTRING(4151.39687094207 3823.42922032493,6112.08612404217 2461.42370862944)
std::stringstream wkbA("01020000000200000098e8f0fe581eaa40ea70df8b95b2a3408c9532b39e5fb340417cd4fc9005b440");
std::stringstream wkbB("010200000002000000ec8455996537b040b834c4c2dbdead4086a8390c16e0b740f86456f0d83aa340");
- GeomAutoPtr a(breader.readHEX(wkbA));
- GeomAutoPtr b(breader.readHEX(wkbB));
+ GeomPtr a(breader.readHEX(wkbA));
+ GeomPtr b(breader.readHEX(wkbB));
// segments do not just touch, but intersect (float-point robustness issue likely)
ensure(!a->touches(b.get()));
diff --git a/tests/unit/geom/GeometryComponentFilterTest.cpp b/tests/unit/geom/GeometryComponentFilterTest.cpp
index 0e3e62a..09fbf11 100644
--- a/tests/unit/geom/GeometryComponentFilterTest.cpp
+++ b/tests/unit/geom/GeometryComponentFilterTest.cpp
@@ -16,10 +16,10 @@ namespace tut
struct test_geometrycomponentfilter_data
{
- typedef geos::geom::Geometry::AutoPtr GeometryPtr; // owner
+ typedef geos::geom::Geometry::Ptr GeometryPtr; // owner
typedef std::vector<geos::geom::Geometry const*> GeometryRefArray; // observer
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKTReader reader;
test_geometrycomponentfilter_data()
: gf(geos::geom::GeometryFactory::create())
diff --git a/tests/unit/geom/GeometryFactoryTest.cpp b/tests/unit/geom/GeometryFactoryTest.cpp
index c91208d..1127a79 100644
--- a/tests/unit/geom/GeometryFactoryTest.cpp
+++ b/tests/unit/geom/GeometryFactoryTest.cpp
@@ -54,7 +54,7 @@ namespace tut
const int srid_;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
test_geometryfactory_data()
@@ -83,7 +83,7 @@ reader_(factory_.get())
void object::test<1>()
{
using geos::geom::GeometryFactory;
- GeometryFactory::unique_ptr gf = GeometryFactory::create();
+ GeometryFactory::Ptr gf = GeometryFactory::create();
ensure_equals( gf->getSRID(), 0 );
ensure_equals( gf->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
@@ -110,7 +110,7 @@ reader_(factory_.get())
{
PrecisionModel pm(1.0);
- GeometryFactory::unique_ptr gf = GeometryFactory::create(&pm, srid_, &csf);
+ GeometryFactory::Ptr gf = GeometryFactory::create(&pm, srid_, &csf);
ensure_equals( gf->getSRID(), srid_ );
ensure_equals( gf->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FIXED );
@@ -140,7 +140,7 @@ reader_(factory_.get())
CoordinateArraySequenceFactory csf;
{
- GeometryFactory::unique_ptr gf = GeometryFactory::create(&csf);
+ GeometryFactory::Ptr gf = GeometryFactory::create(&csf);
ensure_equals( gf->getSRID(), 0 );
ensure_equals( gf->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
@@ -165,7 +165,7 @@ reader_(factory_.get())
using geos::geom::GeometryFactory;
PrecisionModel pm(PrecisionModel::FIXED);
- GeometryFactory::unique_ptr gf(GeometryFactory::create(&pm));
+ GeometryFactory::Ptr gf(GeometryFactory::create(&pm));
ensure_equals( gf->getSRID(), 0 );
ensure_equals( gf->getPrecisionModel()->getType(), PrecisionModel::FIXED );
@@ -188,7 +188,7 @@ reader_(factory_.get())
using geos::geom::GeometryFactory;
PrecisionModel pm(PrecisionModel::FIXED);
- GeometryFactory::unique_ptr gf(GeometryFactory::create(&pm, srid_));
+ GeometryFactory::Ptr gf(GeometryFactory::create(&pm, srid_));
ensure_equals( gf->getSRID(), srid_ );
ensure_equals( gf->getPrecisionModel()->getType(), PrecisionModel::FIXED );
@@ -208,7 +208,7 @@ reader_(factory_.get())
void object::test<6>()
{
using geos::geom::GeometryFactory;
- GeometryFactory::unique_ptr gf(GeometryFactory::create(*factory_));
+ GeometryFactory::Ptr gf(GeometryFactory::create(*factory_));
ensure_equals( factory_->getSRID(), gf->getSRID() );
ensure_equals( factory_->getPrecisionModel()->getType(), gf->getPrecisionModel()->getType() );
@@ -1248,7 +1248,7 @@ reader_(factory_.get())
template<>
void object::test<36>()
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryAutoPtr;
typedef std::vector<PointPtr> PointVect;
const std::size_t size = 3;
diff --git a/tests/unit/geom/GeometryFilterTest.cpp b/tests/unit/geom/GeometryFilterTest.cpp
index 5c56150..c3b1f92 100644
--- a/tests/unit/geom/GeometryFilterTest.cpp
+++ b/tests/unit/geom/GeometryFilterTest.cpp
@@ -16,10 +16,10 @@ namespace tut
struct test_geometryfilter_data
{
- typedef geos::geom::Geometry::AutoPtr GeometryPtr; // owner
+ typedef geos::geom::Geometry::Ptr GeometryPtr; // owner
typedef std::vector<geos::geom::Geometry const*> GeometryRefArray; // observer
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKTReader reader;
test_geometryfilter_data()
: gf(geos::geom::GeometryFactory::create())
diff --git a/tests/unit/geom/LineStringTest.cpp b/tests/unit/geom/LineStringTest.cpp
index 2b004e0..6e13b4a 100644
--- a/tests/unit/geom/LineStringTest.cpp
+++ b/tests/unit/geom/LineStringTest.cpp
@@ -30,10 +30,10 @@ namespace tut
struct test_linestring_data
{
// Typedefs used as short names by test cases
- typedef std::auto_ptr<geos::geom::LineString> LineStringAutoPtr;
+ typedef std::unique_ptr<geos::geom::LineString> LineStringAutoPtr;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
LineStringPtr empty_line_;
diff --git a/tests/unit/geom/LinearRingTest.cpp b/tests/unit/geom/LinearRingTest.cpp
index ec0e940..760a11f 100644
--- a/tests/unit/geom/LinearRingTest.cpp
+++ b/tests/unit/geom/LinearRingTest.cpp
@@ -40,7 +40,7 @@ namespace tut
typedef geos::geom::LinearRing const* LinearRingCPtr;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
geos::geom::LinearRing empty_ring_;
diff --git a/tests/unit/geom/MultiPointTest.cpp b/tests/unit/geom/MultiPointTest.cpp
index cf29e2a..0f6925a 100644
--- a/tests/unit/geom/MultiPointTest.cpp
+++ b/tests/unit/geom/MultiPointTest.cpp
@@ -24,11 +24,11 @@ namespace tut
// Common data used by tests
struct test_multipoint_data
{
- typedef std::auto_ptr<geos::geom::MultiPoint> MultiPointAutoPtr;
+ typedef std::unique_ptr<geos::geom::MultiPoint> MultiPointAutoPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
MultiPointAutoPtr empty_mp_;
diff --git a/tests/unit/geom/PointTest.cpp b/tests/unit/geom/PointTest.cpp
index 6bc2846..8996b0c 100644
--- a/tests/unit/geom/PointTest.cpp
+++ b/tests/unit/geom/PointTest.cpp
@@ -30,16 +30,16 @@ namespace tut
typedef geos::geom::Coordinate const* CoordinateCPtr;
typedef geos::geom::Geometry* GeometryPtr;
- typedef std::auto_ptr<geos::geom::Geometry> GeometryAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryAutoPtr;
typedef geos::geom::Geometry const* GeometryCPtr;
typedef geos::geom::Point* PointPtr;
- typedef std::auto_ptr<geos::geom::Point> PointAutoPtr;
+ typedef std::unique_ptr<geos::geom::Point> PointAutoPtr;
typedef geos::geom::Point const* PointCPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
PointAutoPtr empty_point_;
PointPtr point_;
diff --git a/tests/unit/geom/PolygonTest.cpp b/tests/unit/geom/PolygonTest.cpp
index 0145f2e..2e6b4ef 100644
--- a/tests/unit/geom/PolygonTest.cpp
+++ b/tests/unit/geom/PolygonTest.cpp
@@ -31,12 +31,12 @@ namespace tut
struct test_polygon_data
{
// Typedefs used as short names by test cases
- typedef std::auto_ptr<geos::geom::Geometry> GeometryAutoPtr;
- typedef std::auto_ptr<geos::geom::Polygon> PolygonAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryAutoPtr;
+ typedef std::unique_ptr<geos::geom::Polygon> PolygonAutoPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
PolygonAutoPtr empty_poly_;
diff --git a/tests/unit/geom/prep/PreparedGeometry/touchesTest.cpp b/tests/unit/geom/prep/PreparedGeometry/touchesTest.cpp
index 3d8bee4..0fbf991 100644
--- a/tests/unit/geom/prep/PreparedGeometry/touchesTest.cpp
+++ b/tests/unit/geom/prep/PreparedGeometry/touchesTest.cpp
@@ -23,10 +23,10 @@ namespace tut {
struct test_preparedgeometrytouches_data
{
- typedef std::auto_ptr<geos::geom::prep::PreparedGeometry> PrepGeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::prep::PreparedGeometry> PrepGeomAutoPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
- geos::geom::GeometryFactory::unique_ptr factory;
+ geos::geom::GeometryFactory::Ptr factory;
geos::io::WKTReader reader;
GeometryPtr g1;
GeometryPtr g2;
diff --git a/tests/unit/geom/prep/PreparedGeometryFactoryTest.cpp b/tests/unit/geom/prep/PreparedGeometryFactoryTest.cpp
index 52d7492..170e7c7 100644
--- a/tests/unit/geom/prep/PreparedGeometryFactoryTest.cpp
+++ b/tests/unit/geom/prep/PreparedGeometryFactoryTest.cpp
@@ -31,7 +31,7 @@ namespace tut
GeometryPtr g_;
PreparedGeometryPtr pg_;
geos::geom::PrecisionModel pm_;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
test_preparedgeometryfactory_data()
diff --git a/tests/unit/geom/util/GeometryExtracterTest.cpp b/tests/unit/geom/util/GeometryExtracterTest.cpp
index 3b91049..008d36d 100644
--- a/tests/unit/geom/util/GeometryExtracterTest.cpp
+++ b/tests/unit/geom/util/GeometryExtracterTest.cpp
@@ -26,11 +26,11 @@ namespace tut
struct test_geometryextracter_data
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
typedef geos::io::WKTReader WKTReader;
typedef geos::io::WKTWriter WKTWriter;
diff --git a/tests/unit/io/WKBReaderTest.cpp b/tests/unit/io/WKBReaderTest.cpp
index 5929736..b500765 100644
--- a/tests/unit/io/WKBReaderTest.cpp
+++ b/tests/unit/io/WKBReaderTest.cpp
@@ -31,13 +31,13 @@ namespace tut
struct test_wkbreader_data
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKBReader wkbreader;
geos::io::WKBWriter xdrwkbwriter;
geos::io::WKBWriter ndrwkbwriter;
geos::io::WKTReader wktreader;
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
test_wkbreader_data()
:
diff --git a/tests/unit/io/WKBWriterTest.cpp b/tests/unit/io/WKBWriterTest.cpp
index db666d5..5b3399d 100644
--- a/tests/unit/io/WKBWriterTest.cpp
+++ b/tests/unit/io/WKBWriterTest.cpp
@@ -27,7 +27,7 @@ namespace tut
struct test_wkbwriter_data
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
geos::io::WKBReader wkbreader;
diff --git a/tests/unit/io/WKTReaderTest.cpp b/tests/unit/io/WKTReaderTest.cpp
index 554062c..eabc61a 100644
--- a/tests/unit/io/WKTReaderTest.cpp
+++ b/tests/unit/io/WKTReaderTest.cpp
@@ -26,11 +26,11 @@ namespace tut
struct test_wktreader_data
{
geos::geom::PrecisionModel pm;
- geos::geom::GeometryFactory::unique_ptr gf;
+ geos::geom::GeometryFactory::Ptr gf;
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
test_wktreader_data()
:
@@ -150,7 +150,7 @@ namespace tut
namespace ggm = geos::geom;
namespace gio = geos::io;
ggm::PrecisionModel pm(ggm::PrecisionModel::FLOATING);
- ggm::GeometryFactory::unique_ptr gf = ggm::GeometryFactory::create(&pm);
+ ggm::GeometryFactory::Ptr gf = ggm::GeometryFactory::create(&pm);
gio::WKTReader wktReader(gf.get());
const std::string str = " POINT (0 0) ";
geom.reset(wktReader.read(str)); //HERE IT FAILS
diff --git a/tests/unit/io/WKTWriterTest.cpp b/tests/unit/io/WKTWriterTest.cpp
index bb0f9e5..94be2b0 100644
--- a/tests/unit/io/WKTWriterTest.cpp
+++ b/tests/unit/io/WKTWriterTest.cpp
@@ -27,10 +27,10 @@ namespace tut
typedef geos::geom::GeometryFactory GeometryFactory;
typedef geos::io::WKTReader WKTReader;
typedef geos::io::WKTWriter WKTWriter;
- typedef std::auto_ptr<geos::geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
PrecisionModel pm;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
WKTReader wktreader;
WKTWriter wktwriter;
@@ -138,7 +138,7 @@ namespace tut
void object::test<5>()
{
PrecisionModel pm3(0.001);
- GeometryFactory::unique_ptr gf3(GeometryFactory::create(&pm3));
+ GeometryFactory::Ptr gf3(GeometryFactory::create(&pm3));
WKTReader wktreader3(gf3.get());
GeomPtr geom ( wktreader3.read("POINT(123456 654321)") );
diff --git a/tests/unit/linearref/LengthIndexedLineTest.cpp b/tests/unit/linearref/LengthIndexedLineTest.cpp
index 6b5f705..b9aebb6 100644
--- a/tests/unit/linearref/LengthIndexedLineTest.cpp
+++ b/tests/unit/linearref/LengthIndexedLineTest.cpp
@@ -10,7 +10,7 @@
#include <geos/io/WKTWriter.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Geometry.h> // required for use in auto_ptr
+#include <geos/geom/Geometry.h> // required for use in unique_ptr
#include <geos/geom/LineString.h>
#include <geos/geom/Coordinate.h>
#include <geos/linearref/LengthIndexedLine.h>
@@ -30,7 +30,7 @@ using namespace std;
*/
namespace tut {
-typedef auto_ptr<Geometry> GeomPtr;
+typedef unique_ptr<Geometry> GeomPtr;
static const double TOLERANCE_DIST = 0.001;
struct test_lengthindexedline_data
diff --git a/tests/unit/noding/BasicSegmentStringTest.cpp b/tests/unit/noding/BasicSegmentStringTest.cpp
index cee434c..db8e97f 100644
--- a/tests/unit/noding/BasicSegmentStringTest.cpp
+++ b/tests/unit/noding/BasicSegmentStringTest.cpp
@@ -21,10 +21,10 @@ namespace tut
struct test_basicsegmentstring_data
{
- typedef std::auto_ptr<geos::geom::CoordinateSequence> \
+ typedef std::unique_ptr<geos::geom::CoordinateSequence> \
CoordinateSequenceAutoPtr;
- typedef std::auto_ptr<geos::noding::BasicSegmentString> \
+ typedef std::unique_ptr<geos::noding::BasicSegmentString> \
SegmentStringAutoPtr;
const geos::geom::CoordinateSequenceFactory* csFactory;
diff --git a/tests/unit/noding/NodedSegmentStringTest.cpp b/tests/unit/noding/NodedSegmentStringTest.cpp
index 1bbe752..f89f7e1 100644
--- a/tests/unit/noding/NodedSegmentStringTest.cpp
+++ b/tests/unit/noding/NodedSegmentStringTest.cpp
@@ -21,10 +21,10 @@ namespace tut
struct test_nodedsegmentstring_data
{
- typedef std::auto_ptr<geos::geom::CoordinateSequence> \
+ typedef std::unique_ptr<geos::geom::CoordinateSequence> \
CoordinateSequenceAutoPtr;
- typedef std::auto_ptr<geos::noding::NodedSegmentString> \
+ typedef std::unique_ptr<geos::noding::NodedSegmentString> \
SegmentStringAutoPtr;
const geos::geom::CoordinateSequenceFactory* csFactory;
@@ -255,7 +255,7 @@ namespace tut
// SegmentString::NonConstVect inputStrings;
// inputStrings.push_back(makeSegmentString(cs2.get()).get());
//
-// std::auto_ptr<SegmentString::NonConstVect> nodedStrings(
+// std::unique_ptr<SegmentString::NonConstVect> nodedStrings(
// NodedSegmentString::getNodedSubstrings(inputStrings)
// );
//
diff --git a/tests/unit/noding/OrientedCoordinateArray.cpp b/tests/unit/noding/OrientedCoordinateArray.cpp
index 01867b2..fa9c42e 100644
--- a/tests/unit/noding/OrientedCoordinateArray.cpp
+++ b/tests/unit/noding/OrientedCoordinateArray.cpp
@@ -29,11 +29,11 @@ namespace tut
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
- typedef std::auto_ptr<CoordinateSequence> CoordSeqPtr;
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<CoordinateSequence> CoordSeqPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
test_orientedcoordinatearray_data()
: pm_()
diff --git a/tests/unit/noding/SegmentNodeTest.cpp b/tests/unit/noding/SegmentNodeTest.cpp
index f396e4a..05712a3 100644
--- a/tests/unit/noding/SegmentNodeTest.cpp
+++ b/tests/unit/noding/SegmentNodeTest.cpp
@@ -21,10 +21,10 @@ namespace tut
struct test_segmentnode_data
{
- typedef std::auto_ptr<geos::geom::CoordinateSequence>
+ typedef std::unique_ptr<geos::geom::CoordinateSequence>
CoordSeqPtr;
- typedef std::auto_ptr<geos::noding::SegmentString>
+ typedef std::unique_ptr<geos::noding::SegmentString>
SegmentStringPtr;
const geos::geom::CoordinateSequenceFactory* factory_;
diff --git a/tests/unit/noding/SegmentPointComparatorTest.cpp b/tests/unit/noding/SegmentPointComparatorTest.cpp
index 99a995c..9fb1f06 100644
--- a/tests/unit/noding/SegmentPointComparatorTest.cpp
+++ b/tests/unit/noding/SegmentPointComparatorTest.cpp
@@ -28,10 +28,10 @@ namespace tut
struct test_segmentpointcomparator_data
{
- typedef std::auto_ptr<geos::geom::CoordinateSequence>
+ typedef std::unique_ptr<geos::geom::CoordinateSequence>
CoordinateSequenceAutoPtr;
- typedef std::auto_ptr<geos::noding::SegmentString>
+ typedef std::unique_ptr<geos::noding::SegmentString>
SegmentStringAutoPtr;
typedef geos::geom::Coordinate Coordinate;
diff --git a/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp b/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp
index 8c44b8c..ee5af63 100644
--- a/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp
+++ b/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp
@@ -49,8 +49,8 @@ namespace tut
typedef geos::geom::PrecisionModel PrecisionModel;
typedef geos::geom::CoordinateSequence CoordinateSequence;
- typedef std::auto_ptr<CoordinateSequence> CoordSeqPtr;
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<CoordinateSequence> CoordSeqPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
typedef std::vector<SegmentString*> SegStrVct;
typedef std::vector<Geometry*> GeomVct;
@@ -136,7 +136,7 @@ namespace tut
ensure_equals( nodable.size(), 1u );
noder.computeNodes(&nodable);
- std::auto_ptr<SegStrVct> noded ( noder.getNodedSubstrings() );
+ std::unique_ptr<SegStrVct> noded ( noder.getNodedSubstrings() );
ensure_equals( "1e-5", noded->size(), 178u );
diff --git a/tests/unit/operation/IsSimpleOpTest.cpp b/tests/unit/operation/IsSimpleOpTest.cpp
index b1f995f..03cd68b 100644
--- a/tests/unit/operation/IsSimpleOpTest.cpp
+++ b/tests/unit/operation/IsSimpleOpTest.cpp
@@ -28,7 +28,7 @@ namespace tut
{
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
double tolerance_;
@@ -55,7 +55,7 @@ namespace tut
void object::test<1>()
{
const std::string wkt("MULTILINESTRING ((20 120, 120 20), (20 20, 120 120))");
- const Geometry::AutoPtr geom(reader_.read(wkt));
+ const Geometry::Ptr geom(reader_.read(wkt));
// TODO - mloskot: What about support of new features of BoundaryNodeRule, in JTS
@@ -79,7 +79,7 @@ namespace tut
void object::test<2>()
{
const std::string wkt("MULTILINESTRING ((100 100, 20 20, 200 20, 100 100), (100 200, 100 100))");
- const Geometry::AutoPtr geom(reader_.read(wkt));
+ const Geometry::Ptr geom(reader_.read(wkt));
IsSimpleOp op;
bool simple = op.isSimpleLinearGeometry(geom.get());
@@ -93,7 +93,7 @@ namespace tut
void object::test<3>()
{
const std::string wkt("LINESTRING (100 100, 20 20, 200 20, 100 100)");
- const Geometry::AutoPtr geom(reader_.read(wkt));
+ const Geometry::Ptr geom(reader_.read(wkt));
IsSimpleOp op;
bool simple = op.isSimpleLinearGeometry(geom.get());
diff --git a/tests/unit/operation/buffer/BufferBuilderTest.cpp b/tests/unit/operation/buffer/BufferBuilderTest.cpp
index 9535b39..26ee047 100644
--- a/tests/unit/operation/buffer/BufferBuilderTest.cpp
+++ b/tests/unit/operation/buffer/BufferBuilderTest.cpp
@@ -33,8 +33,8 @@ namespace tut
geos::io::WKTReader wktreader;
int const default_quadrant_segments;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
- typedef std::auto_ptr<geos::geom::CoordinateSequence> CSPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
+ typedef std::unique_ptr<geos::geom::CoordinateSequence> CSPtr;
test_bufferbuilder_data()
: gf(*geos::geom::GeometryFactory::getDefaultInstance())
diff --git a/tests/unit/operation/buffer/BufferOpTest.cpp b/tests/unit/operation/buffer/BufferOpTest.cpp
index 6eb25b9..f5c6009 100644
--- a/tests/unit/operation/buffer/BufferOpTest.cpp
+++ b/tests/unit/operation/buffer/BufferOpTest.cpp
@@ -31,8 +31,8 @@ namespace tut
geos::io::WKTReader wktreader;
int const default_quadrant_segments;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
- typedef std::auto_ptr<geos::geom::CoordinateSequence> CSPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
+ typedef std::unique_ptr<geos::geom::CoordinateSequence> CSPtr;
test_bufferop_data()
: gf(*geos::geom::GeometryFactory::getDefaultInstance())
diff --git a/tests/unit/operation/distance/DistanceOpTest.cpp b/tests/unit/operation/distance/DistanceOpTest.cpp
index ceaae08..22914a4 100644
--- a/tests/unit/operation/distance/DistanceOpTest.cpp
+++ b/tests/unit/operation/distance/DistanceOpTest.cpp
@@ -30,8 +30,8 @@ namespace tut
{
geos::io::WKTReader wktreader;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
- typedef std::auto_ptr<geos::geom::CoordinateSequence> CSPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
+ typedef std::unique_ptr<geos::geom::CoordinateSequence> CSPtr;
test_distanceop_data()
: wktreader()
@@ -466,7 +466,7 @@ namespace tut
const char* wkb_geom2 = "010100000000000000000000000000000000000000";
geos::geom::PrecisionModel precision(geos::geom::PrecisionModel::FLOATING);
- GeometryFactory::unique_ptr f(GeometryFactory::create(&precision));
+ GeometryFactory::Ptr f(GeometryFactory::create(&precision));
std::istringstream istr1(wkb_geom1);
std::istringstream istr2(wkb_geom2);
geos::io::WKBReader wkb(*f);
diff --git a/tests/unit/operation/intersection/RectangleIntersectionTest.cpp b/tests/unit/operation/intersection/RectangleIntersectionTest.cpp
index 3b31f74..0bd73eb 100644
--- a/tests/unit/operation/intersection/RectangleIntersectionTest.cpp
+++ b/tests/unit/operation/intersection/RectangleIntersectionTest.cpp
@@ -29,7 +29,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
typedef geos::geom::Geometry Geom;
typedef geos::operation::intersection::Rectangle Rectangle;
typedef geos::operation::intersection::RectangleIntersection RectangleIntersection;
diff --git a/tests/unit/operation/linemerge/LineMergerTest.cpp b/tests/unit/operation/linemerge/LineMergerTest.cpp
index 817f96b..707d1ba 100644
--- a/tests/unit/operation/linemerge/LineMergerTest.cpp
+++ b/tests/unit/operation/linemerge/LineMergerTest.cpp
@@ -34,7 +34,7 @@ namespace tut
geos::io::WKTWriter wktwriter;
typedef geos::geom::Geometry Geom;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
GeomVect inpGeoms;
GeomVect expGeoms;
diff --git a/tests/unit/operation/linemerge/LineSequencerTest.cpp b/tests/unit/operation/linemerge/LineSequencerTest.cpp
index a49b9f2..a34ec88 100644
--- a/tests/unit/operation/linemerge/LineSequencerTest.cpp
+++ b/tests/unit/operation/linemerge/LineSequencerTest.cpp
@@ -34,7 +34,7 @@ namespace tut
geos::io::WKTWriter wktwriter;
typedef geos::geom::Geometry Geom;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
GeomVect inpGeoms;
diff --git a/tests/unit/operation/overlay/OverlayOpUnionTest.cpp b/tests/unit/operation/overlay/OverlayOpUnionTest.cpp
index 2ebcc62..638d1e5 100644
--- a/tests/unit/operation/overlay/OverlayOpUnionTest.cpp
+++ b/tests/unit/operation/overlay/OverlayOpUnionTest.cpp
@@ -24,9 +24,9 @@ namespace tut
struct test_overlayopunion_data
{
- typedef geos::geom::Geometry::AutoPtr GeometryPtr;
+ typedef geos::geom::Geometry::Ptr GeometryPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
- typedef geos::geom::GeometryFactory::unique_ptr GeometryFactoryPtr;
+ typedef geos::geom::GeometryFactory::Ptr GeometryFactoryPtr;
};
typedef test_group<test_overlayopunion_data> group;
diff --git a/tests/unit/operation/overlay/snap/GeometrySnapperTest.cpp b/tests/unit/operation/overlay/snap/GeometrySnapperTest.cpp
index 51d8a64..5e39148 100644
--- a/tests/unit/operation/overlay/snap/GeometrySnapperTest.cpp
+++ b/tests/unit/operation/overlay/snap/GeometrySnapperTest.cpp
@@ -22,7 +22,7 @@ namespace tut
// Common data used by tests
struct test_geometrysnapper_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeomAutoPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeomPtr;
geos::io::WKTReader reader;
@@ -49,21 +49,21 @@ namespace tut
template<>
void object::test<1>()
{
- GeomAutoPtr src(reader.read(
+ GeomPtr src(reader.read(
"POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))"
));
GeometrySnapper snapper( *(src.get()) );
- GeomAutoPtr snap(reader.read(
+ GeomPtr snap(reader.read(
"MULTIPOINT ((0 0), (0 100.0000001), (100 100), (100 0))"
));
- GeomAutoPtr expected(reader.read(
+ GeomPtr expected(reader.read(
"POLYGON ((0 0, 0 100.0000001, 100 100, 100 0, 0 0))"
));
- GeomAutoPtr ret(snapper.snapTo( *(snap.get()), 0.000001 ));
+ GeomPtr ret(snapper.snapTo( *(snap.get()), 0.000001 ));
ensure( ret->equalsExact(expected.get(),0) );
@@ -74,21 +74,21 @@ namespace tut
template<>
void object::test<2>()
{
- GeomAutoPtr src(reader.read(
+ GeomPtr src(reader.read(
"POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))"
));
GeometrySnapper snapper( *(src.get()) );
- GeomAutoPtr snap(reader.read(
+ GeomPtr snap(reader.read(
"MULTIPOINT ((0.0000001 50))"
));
- GeomAutoPtr expected(reader.read(
+ GeomPtr expected(reader.read(
"POLYGON ((0 0, 0.0000001 50, 0 100, 100 100, 100 0, 0 0))"
));
- GeomAutoPtr ret(snapper.snapTo( *(snap.get()), 0.000001 ));
+ GeomPtr ret(snapper.snapTo( *(snap.get()), 0.000001 ));
ensure( ret->equalsExact(expected.get(),0) );
}
diff --git a/tests/unit/operation/overlay/snap/LineStringSnapperTest.cpp b/tests/unit/operation/overlay/snap/LineStringSnapperTest.cpp
index b4fb290..72f66f1 100644
--- a/tests/unit/operation/overlay/snap/LineStringSnapperTest.cpp
+++ b/tests/unit/operation/overlay/snap/LineStringSnapperTest.cpp
@@ -42,7 +42,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -80,7 +80,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -119,7 +119,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -164,7 +164,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -196,7 +196,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -223,7 +223,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// source coordinates
@@ -252,7 +252,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// Source: (0 0, 10 0, 0 1)
@@ -300,7 +300,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// Source: (0 0, 1 0, 1 1)
@@ -338,7 +338,7 @@ namespace tut
using geos::geom::Coordinate;
using geos::operation::overlay::snap::LineStringSnapper;
- typedef std::auto_ptr<Coordinate::Vect> CoordsVectAptr;
+ typedef std::unique_ptr<Coordinate::Vect> CoordsVectAptr;
// Source: (1 1, 5 9, 9 1, 1 1)
diff --git a/tests/unit/operation/overlay/validate/FuzzyPointLocatorTest.cpp b/tests/unit/operation/overlay/validate/FuzzyPointLocatorTest.cpp
index 1bc35e1..bce5b83 100644
--- a/tests/unit/operation/overlay/validate/FuzzyPointLocatorTest.cpp
+++ b/tests/unit/operation/overlay/validate/FuzzyPointLocatorTest.cpp
@@ -28,7 +28,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKBReader wkbreader;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
GeomPtr g;
diff --git a/tests/unit/operation/overlay/validate/OffsetPointGeneratorTest.cpp b/tests/unit/operation/overlay/validate/OffsetPointGeneratorTest.cpp
index c5e6c30..cb61fc6 100644
--- a/tests/unit/operation/overlay/validate/OffsetPointGeneratorTest.cpp
+++ b/tests/unit/operation/overlay/validate/OffsetPointGeneratorTest.cpp
@@ -31,7 +31,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::algorithm::PointLocator locator;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
GeomPtr g;
@@ -55,7 +55,7 @@ namespace tut
for (size_t i=0, n=coords.size(); i<n; ++i)
{
const Coordinate& c = coords[i];
- auto_ptr<Geometry> pg(gf.createPoint(c));
+ unique_ptr<Geometry> pg(gf.createPoint(c));
double rdist = g->distance(pg.get());
if ( rdist > dist )
{
@@ -84,7 +84,7 @@ namespace tut
using geos::operation::overlay::validate::OffsetPointGenerator;
using geos::geom::Coordinate;
using geos::algorithm::PointLocator;
- using std::auto_ptr;
+ using std::unique_ptr;
using std::vector;
std::string wkt("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
@@ -93,7 +93,7 @@ namespace tut
double dist = 10;
OffsetPointGenerator gen(*g, dist);
- auto_ptr< vector<Coordinate> > coords(gen.getPoints());
+ unique_ptr< vector<Coordinate> > coords(gen.getPoints());
ensure_equals(coords->size(), (g->getNumPoints()-1)*2);
@@ -108,7 +108,7 @@ namespace tut
using geos::operation::overlay::validate::OffsetPointGenerator;
using geos::geom::Location;
using geos::geom::Coordinate;
- using std::auto_ptr;
+ using std::unique_ptr;
using std::vector;
std::string wkt("POLYGON((0 0, 10 0, 10 5, 10 10, 0 10, 0 0))");
@@ -118,7 +118,7 @@ namespace tut
OffsetPointGenerator gen(*g, dist);
- auto_ptr< vector<Coordinate> > coords(gen.getPoints());
+ unique_ptr< vector<Coordinate> > coords(gen.getPoints());
ensure_equals(coords->size(), 10u);
@@ -132,7 +132,7 @@ namespace tut
using geos::operation::overlay::validate::OffsetPointGenerator;
using geos::geom::Location;
using geos::geom::Coordinate;
- using std::auto_ptr;
+ using std::unique_ptr;
using std::vector;
std::string wkt("POINT(10 -10)");
@@ -142,7 +142,7 @@ namespace tut
OffsetPointGenerator gen(*g, dist);
- auto_ptr< vector<Coordinate> > coords(gen.getPoints());
+ unique_ptr< vector<Coordinate> > coords(gen.getPoints());
ensure_equals(coords->size(), 0u);
@@ -156,7 +156,7 @@ namespace tut
using geos::operation::overlay::validate::OffsetPointGenerator;
using geos::geom::Location;
using geos::geom::Coordinate;
- using std::auto_ptr;
+ using std::unique_ptr;
using std::vector;
std::string wkt("LINESTRING(10 -10, 5 600)");
@@ -166,7 +166,7 @@ namespace tut
OffsetPointGenerator gen(*g, dist);
- auto_ptr< vector<Coordinate> > coords(gen.getPoints());
+ unique_ptr< vector<Coordinate> > coords(gen.getPoints());
ensure_equals(coords->size(), 2u);
@@ -180,7 +180,7 @@ namespace tut
using geos::operation::overlay::validate::OffsetPointGenerator;
using geos::geom::Location;
using geos::geom::Coordinate;
- using std::auto_ptr;
+ using std::unique_ptr;
using std::vector;
std::string wkt("MULTILINESTRING((10 -10, 5 600), (1045 -12, 0 0, -435 34))");
@@ -190,7 +190,7 @@ namespace tut
OffsetPointGenerator gen(*g, dist);
- auto_ptr< vector<Coordinate> > coords(gen.getPoints());
+ unique_ptr< vector<Coordinate> > coords(gen.getPoints());
ensure_equals(coords->size(), 6u);
diff --git a/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp b/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
index fda1585..e790fdf 100644
--- a/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
+++ b/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
@@ -30,7 +30,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::algorithm::PointLocator locator;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
GeomPtr g0, g1, gres;
diff --git a/tests/unit/operation/polygonize/PolygonizeTest.cpp b/tests/unit/operation/polygonize/PolygonizeTest.cpp
index 6072e67..c10eb39 100644
--- a/tests/unit/operation/polygonize/PolygonizeTest.cpp
+++ b/tests/unit/operation/polygonize/PolygonizeTest.cpp
@@ -32,7 +32,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
typedef geos::geom::Geometry Geom;
typedef geos::geom::Polygon Poly;
typedef geos::operation::polygonize::Polygonizer Polygonizer;
@@ -119,7 +119,7 @@ namespace tut
Polygonizer polygonizer;
polygonizer.add(&inputGeoms);
- std::auto_ptr< std::vector<Poly*> > retGeoms;
+ std::unique_ptr< std::vector<Poly*> > retGeoms;
retGeoms.reset( polygonizer.getPolygons() );
delAll(inputGeoms);
diff --git a/tests/unit/operation/sharedpaths/SharedPathsOpTest.cpp b/tests/unit/operation/sharedpaths/SharedPathsOpTest.cpp
index 49fd49a..20ef98e 100644
--- a/tests/unit/operation/sharedpaths/SharedPathsOpTest.cpp
+++ b/tests/unit/operation/sharedpaths/SharedPathsOpTest.cpp
@@ -31,7 +31,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
SharedPathsOp::PathList forwDir;
SharedPathsOp::PathList backDir;
diff --git a/tests/unit/operation/union/CascadedPolygonUnionTest.cpp b/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
index b161dc9..dadba85 100644
--- a/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
+++ b/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
@@ -29,7 +29,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
test_cascadedpolygonuniontest_data()
: gf(*geos::geom::GeometryFactory::getDefaultInstance())
@@ -48,7 +48,7 @@ namespace tut
{
typedef std::vector<geos::geom::Polygon*>::iterator iterator;
- std::auto_ptr<geos::geom::Geometry> unionAll;
+ std::unique_ptr<geos::geom::Geometry> unionAll;
iterator end = geoms->end();
for (iterator i = geoms->begin(); i != end; ++i)
{
@@ -74,8 +74,8 @@ namespace tut
void test_runner(test_cascadedpolygonuniontest_data& t,
std::vector<geos::geom::Polygon*>* geoms)
{
- std::auto_ptr<geos::geom::Geometry> union1(unionIterated(geoms));
- std::auto_ptr<geos::geom::Geometry> union2(unionCascaded(geoms));
+ std::unique_ptr<geos::geom::Geometry> union1(unionIterated(geoms));
+ std::unique_ptr<geos::geom::Geometry> union2(unionCascaded(geoms));
// For now we compare the WKT representations of the two generated
// geometries which works well for simple geometries only.
@@ -127,7 +127,7 @@ namespace tut
{
for (int i = 0; i < num; ++i) {
for (int j = 0; j < num; ++j) {
- std::auto_ptr<geos::geom::Point> pt(
+ std::unique_ptr<geos::geom::Point> pt(
gf.createPoint(geos::geom::Coordinate(i, j)));
g->push_back(dynamic_cast<geos::geom::Polygon*>(pt->buffer(radius)));
}
diff --git a/tests/unit/operation/union/UnaryUnionOpTest.cpp b/tests/unit/operation/union/UnaryUnionOpTest.cpp
index 9e92ebb..d98e03c 100644
--- a/tests/unit/operation/union/UnaryUnionOpTest.cpp
+++ b/tests/unit/operation/union/UnaryUnionOpTest.cpp
@@ -27,11 +27,11 @@ namespace tut
struct test_unaryuniontest_data
{
typedef geos::geom::GeometryFactory GeometryFactory;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
typedef geos::geom::Geometry Geom;
typedef geos::operation::geounion::UnaryUnionOp UnaryUnionOp;
diff --git a/tests/unit/operation/valid/IsValidTest.cpp b/tests/unit/operation/valid/IsValidTest.cpp
index c13c2ad..373fc0c 100644
--- a/tests/unit/operation/valid/IsValidTest.cpp
+++ b/tests/unit/operation/valid/IsValidTest.cpp
@@ -32,11 +32,11 @@ namespace tut
struct test_isvalidop_data
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
test_isvalidop_data()
: pm_(1), factory_(GeometryFactory::create(&pm_, 0))
diff --git a/tests/unit/operation/valid/ValidClosedRingTest.cpp b/tests/unit/operation/valid/ValidClosedRingTest.cpp
index 55ab3e3..d924848 100644
--- a/tests/unit/operation/valid/ValidClosedRingTest.cpp
+++ b/tests/unit/operation/valid/ValidClosedRingTest.cpp
@@ -37,11 +37,11 @@ namespace tut
struct test_validclosedring_data
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader rdr;
test_validclosedring_data()
diff --git a/tests/unit/operation/valid/ValidSelfTouchingRingFormingHoleTest.cpp b/tests/unit/operation/valid/ValidSelfTouchingRingFormingHoleTest.cpp
index b3f4491..4cb8787 100644
--- a/tests/unit/operation/valid/ValidSelfTouchingRingFormingHoleTest.cpp
+++ b/tests/unit/operation/valid/ValidSelfTouchingRingFormingHoleTest.cpp
@@ -37,11 +37,11 @@ namespace tut
struct test_ValidSelfTouchingRingFormingHole_data
{
- typedef std::auto_ptr<Geometry> GeomPtr;
+ typedef std::unique_ptr<Geometry> GeomPtr;
geos::geom::PrecisionModel pm_;
typedef geos::geom::GeometryFactory GeometryFactory;
- geos::geom::GeometryFactory::unique_ptr factory_;
+ geos::geom::GeometryFactory::Ptr factory_;
geos::io::WKTReader rdr;
test_ValidSelfTouchingRingFormingHole_data()
diff --git a/tests/unit/precision/GeometryPrecisionReducerTest.cpp b/tests/unit/precision/GeometryPrecisionReducerTest.cpp
index c06fd39..b4a40f2 100644
--- a/tests/unit/precision/GeometryPrecisionReducerTest.cpp
+++ b/tests/unit/precision/GeometryPrecisionReducerTest.cpp
@@ -24,13 +24,13 @@ namespace tut
// Common data used by tests
struct test_gpr_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_float_;
geos::geom::PrecisionModel pm_fixed_;
- GeometryFactory::unique_ptr factory_;
- GeometryFactory::unique_ptr factory_fixed_;
+ GeometryFactory::Ptr factory_;
+ GeometryFactory::Ptr factory_fixed_;
geos::io::WKTReader reader_;
geos::precision::GeometryPrecisionReducer reducer_;
geos::precision::GeometryPrecisionReducer reducerKeepCollapse_; // keep collapse
diff --git a/tests/unit/precision/SimpleGeometryPrecisionReducerTest.cpp b/tests/unit/precision/SimpleGeometryPrecisionReducerTest.cpp
index 7bab41e..051e3d3 100644
--- a/tests/unit/precision/SimpleGeometryPrecisionReducerTest.cpp
+++ b/tests/unit/precision/SimpleGeometryPrecisionReducerTest.cpp
@@ -22,12 +22,12 @@ namespace tut
// Common data used by tests
struct test_sgpr_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_float_;
geos::geom::PrecisionModel pm_fixed_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
geos::precision::SimpleGeometryPrecisionReducer reducer_;
geos::precision::SimpleGeometryPrecisionReducer reducer2_; // keep collapse
diff --git a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
index 694cb08..edeb61d 100644
--- a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
+++ b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
@@ -30,7 +30,7 @@ namespace tut
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
test_dpsimp_data()
:
diff --git a/tests/unit/simplify/TopologyPreservingSimplifierTest.cpp b/tests/unit/simplify/TopologyPreservingSimplifierTest.cpp
index 95f5273..e54787f 100644
--- a/tests/unit/simplify/TopologyPreservingSimplifierTest.cpp
+++ b/tests/unit/simplify/TopologyPreservingSimplifierTest.cpp
@@ -29,11 +29,11 @@ namespace tut
{
geos::geom::PrecisionModel pm;
typedef geos::geom::GeometryFactory GeometryFactory;
- GeometryFactory::unique_ptr gf;
+ GeometryFactory::Ptr gf;
geos::io::WKTReader wktreader;
geos::io::WKTWriter wktwriter;
- typedef geos::geom::Geometry::AutoPtr GeomPtr;
+ typedef geos::geom::Geometry::Ptr GeomPtr;
test_tpsimp_data()
: pm(1.0)
diff --git a/tests/unit/triangulate/DelaunayTest.cpp b/tests/unit/triangulate/DelaunayTest.cpp
index 9dc9df2..21db61e 100644
--- a/tests/unit/triangulate/DelaunayTest.cpp
+++ b/tests/unit/triangulate/DelaunayTest.cpp
@@ -44,7 +44,7 @@ namespace tut
void runDelaunay(const char *sitesWkt, bool computeTriangles, const char *expectedWkt, double tolerance=0.0)
{
WKTReader reader;
- std::auto_ptr<Geometry> results;
+ std::unique_ptr<Geometry> results;
Geometry *sites = reader.read(sitesWkt);
Geometry *expected = reader.read(expectedWkt);
DelaunayTriangulationBuilder builder;
@@ -85,7 +85,7 @@ namespace tut
//extract the triangles from the subdivision
const GeometryFactory& geomFact(*GeometryFactory::getDefaultInstance());
- std::auto_ptr<GeometryCollection> tris = sub.getTriangles(geomFact);
+ std::unique_ptr<GeometryCollection> tris = sub.getTriangles(geomFact);
}
// 2 - Test Triangle
diff --git a/tests/unit/triangulate/VoronoiTest.cpp b/tests/unit/triangulate/VoronoiTest.cpp
index 777fba8..07d8a1c 100644
--- a/tests/unit/triangulate/VoronoiTest.cpp
+++ b/tests/unit/triangulate/VoronoiTest.cpp
@@ -49,9 +49,9 @@ namespace tut
WKTReader reader;
WKTWriter writer;
geos::triangulate::VoronoiDiagramBuilder builder;
- std::auto_ptr<Geometry> sites ( reader.read(sitesWkt) );
- std::auto_ptr<Geometry> expected ( reader.read(expectedWkt) );
- std::auto_ptr<GeometryCollection> results;
+ std::unique_ptr<Geometry> sites ( reader.read(sitesWkt) );
+ std::unique_ptr<Geometry> expected ( reader.read(expectedWkt) );
+ std::unique_ptr<GeometryCollection> results;
const GeometryFactory& geomFact(*GeometryFactory::getDefaultInstance());
builder.setSites(*sites);
@@ -87,7 +87,7 @@ namespace tut
Coordinate d(244,284);
geos::triangulate::VoronoiDiagramBuilder builder;
- std::auto_ptr< std::vector<Coordinate> > v(new std::vector<Coordinate>());
+ std::unique_ptr< std::vector<Coordinate> > v(new std::vector<Coordinate>());
v->push_back(a);
v->push_back(b);
v->push_back(c);
@@ -97,7 +97,7 @@ namespace tut
builder.setSites(seq);
//getting the subdiv()
- std::auto_ptr<QuadEdgeSubdivision> subdiv = builder.getSubdivision();
+ std::unique_ptr<QuadEdgeSubdivision> subdiv = builder.getSubdivision();
ensure_equals(subdiv->getTolerance() , 0);
ensure_equals(subdiv->getEnvelope().toString(),"Env[-3540:4020,-3436:4050]");
diff --git a/tests/unit/triangulate/quadedge/QuadEdgeSubdivisionTest.cpp b/tests/unit/triangulate/quadedge/QuadEdgeSubdivisionTest.cpp
index b7e65a1..fd3aaf1 100644
--- a/tests/unit/triangulate/quadedge/QuadEdgeSubdivisionTest.cpp
+++ b/tests/unit/triangulate/quadedge/QuadEdgeSubdivisionTest.cpp
@@ -74,8 +74,8 @@ namespace tut
ensure(!sub.isOnEdge(e, Coordinate(10, 10)));
ensure(!sub.isVertexOfEdge(e, Vertex(10, 10)));
- GeometryFactory::unique_ptr geomFact(GeometryFactory::create());
- std::auto_ptr<GeometryCollection> tris = sub.getTriangles(*geomFact);
+ GeometryFactory::Ptr geomFact(GeometryFactory::create());
+ std::unique_ptr<GeometryCollection> tris = sub.getTriangles(*geomFact);
tris.reset();
//WKTWriter wkt;
//printf("%s\n", wkt.writeFormatted(tris).c_str());
@@ -100,7 +100,7 @@ namespace tut
//Test for getVoronoiDiagram::
const GeometryFactory& geomFact(*GeometryFactory::getDefaultInstance());
- std::auto_ptr<GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
+ std::unique_ptr<GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
const char *expected_str = "GEOMETRYCOLLECTION (POLYGON ((-5849.974929324658 2268.0517257497568, -4529.9920486948895 2247.139449440667, 221.20588235294116 210.91176470588235, -684.4227119984187 -2848.644297291955, -5849.974929324658 2268.0517257497568)), POLYGON ((212.5 -3774.5, -684.4227119984187 -2848.644297291955, 221.20588235294116 210.91176470588235, 2448.7167655626645 2188.608343256571, 6235.0370264064295 2248.0370264064295, 212.5 -3774.5)), POLYGON ((-4529.9920486948895 2247.139449440667, 2448.7167655626645 2188.608343256571, 221.20588235294116 210.91176470588235, -4529.9920486948895 2247.139449440667)))";
// std::cout << polys->toString() << std::endl;
@@ -127,19 +127,19 @@ namespace tut
" (230 250),"
" (210 290)"
")";
- std::auto_ptr<Geometry> sites ( reader.read(wkt) );
- std::auto_ptr<CoordinateSequence> siteCoords (
+ std::unique_ptr<Geometry> sites ( reader.read(wkt) );
+ std::unique_ptr<CoordinateSequence> siteCoords (
DelaunayTriangulationBuilder::extractUniqueCoordinates(*sites)
);
Envelope env = DelaunayTriangulationBuilder::envelope(*siteCoords);
double expandBy = std::max(env.getWidth() , env.getHeight());
env.expandBy(expandBy);
- std::auto_ptr<QuadEdgeSubdivision> subdiv(
+ std::unique_ptr<QuadEdgeSubdivision> subdiv(
new quadedge::QuadEdgeSubdivision(env,10)
);
- std::auto_ptr<IncrementalDelaunayTriangulator::VertexList> vertices (
+ std::unique_ptr<IncrementalDelaunayTriangulator::VertexList> vertices (
DelaunayTriangulationBuilder::toVertices(*siteCoords)
);
@@ -148,11 +148,11 @@ namespace tut
//Test for getVoronoiDiagram::
const GeometryFactory& geomFact(*GeometryFactory::getDefaultInstance());
- std::auto_ptr<GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
+ std::unique_ptr<GeometryCollection> polys = subdiv->getVoronoiDiagram(geomFact);
for (std::size_t i=0; i<polys->getNumGeometries(); ++i) {
const Polygon* p = dynamic_cast<const Polygon*>(polys->getGeometryN(i));
ensure(p);
- std::auto_ptr<CoordinateSequence> cs (
+ std::unique_ptr<CoordinateSequence> cs (
p->getExteriorRing()->getCoordinates()
);
size_t from = cs->size();
diff --git a/tests/unit/triangulate/quadedge/QuadEdgeTest.cpp b/tests/unit/triangulate/quadedge/QuadEdgeTest.cpp
index 9d961c4..f9a46bb 100644
--- a/tests/unit/triangulate/quadedge/QuadEdgeTest.cpp
+++ b/tests/unit/triangulate/quadedge/QuadEdgeTest.cpp
@@ -46,9 +46,9 @@ namespace tut
Vertex v3(1, 0);
Vertex v4(1, 1);
- std::auto_ptr<QuadEdge> q0;
- std::auto_ptr<QuadEdge> r0;
- std::auto_ptr<QuadEdge> s0;
+ std::unique_ptr<QuadEdge> q0;
+ std::unique_ptr<QuadEdge> r0;
+ std::unique_ptr<QuadEdge> s0;
q0 = QuadEdge::makeEdge(v1, v2);
r0 = QuadEdge::makeEdge(v3, v4);
@@ -78,9 +78,9 @@ namespace tut
Vertex v3(1, 0);
Vertex v4(1, 1);
- std::auto_ptr<QuadEdge> q0;
- std::auto_ptr<QuadEdge> r0;
- std::auto_ptr<QuadEdge> s0;
+ std::unique_ptr<QuadEdge> q0;
+ std::unique_ptr<QuadEdge> r0;
+ std::unique_ptr<QuadEdge> s0;
q0 = QuadEdge::makeEdge(v1, v2);
r0 = QuadEdge::makeEdge(v2, v3);
@@ -110,11 +110,11 @@ namespace tut
Vertex v3(1, 0);
Vertex v4(1, 1);
- std::auto_ptr<QuadEdge> q0;
- std::auto_ptr<QuadEdge> r0;
- std::auto_ptr<QuadEdge> s0;
- std::auto_ptr<QuadEdge> t0;
- std::auto_ptr<QuadEdge> u0;
+ std::unique_ptr<QuadEdge> q0;
+ std::unique_ptr<QuadEdge> r0;
+ std::unique_ptr<QuadEdge> s0;
+ std::unique_ptr<QuadEdge> t0;
+ std::unique_ptr<QuadEdge> u0;
//make a quadilateral
q0 = QuadEdge::makeEdge(v1, v2);
diff --git a/tests/unit/util/UniqueCoordinateArrayFilterTest.cpp b/tests/unit/util/UniqueCoordinateArrayFilterTest.cpp
index 1e1cf33..491683a 100644
--- a/tests/unit/util/UniqueCoordinateArrayFilterTest.cpp
+++ b/tests/unit/util/UniqueCoordinateArrayFilterTest.cpp
@@ -24,11 +24,11 @@ namespace tut
// Common data used in test cases.
struct test_uniquecoordinatearrayfilter_data
{
- typedef std::auto_ptr<geos::geom::Geometry> GeometryPtr;
+ typedef std::unique_ptr<geos::geom::Geometry> GeometryPtr;
typedef geos::geom::GeometryFactory GeometryFactory;
geos::geom::PrecisionModel pm_;
- GeometryFactory::unique_ptr factory_;
+ GeometryFactory::Ptr factory_;
geos::io::WKTReader reader_;
test_uniquecoordinatearrayfilter_data()
@@ -60,7 +60,7 @@ namespace tut
GeometryPtr geo(reader_.read(wkt));
ensure_equals( geo->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );
- std::auto_ptr<geos::geom::CoordinateSequence> cs;
+ std::unique_ptr<geos::geom::CoordinateSequence> cs;
cs.reset(geo->getCoordinates());
ensure_equals(cs->getSize(), size5 );
diff --git a/tests/unit/utility.h b/tests/unit/utility.h
index cb5e520..4a58d7a 100644
--- a/tests/unit/utility.h
+++ b/tests/unit/utility.h
@@ -90,23 +90,6 @@ inline Type const* instanceOf(InstanceType const* instance)
return dynamic_cast<Type const*>(instance);
}
-template <typename Dst, typename Src>
-std::auto_ptr<Dst> dynamic_cast_auto_ptr(std::auto_ptr<Src>& ptr)
-{
- Dst* res = dynamic_cast<Dst*>(ptr.get());
- if (0 != res)
- {
- ptr.release();
- }
- return std::auto_ptr<Dst>(res);
-}
-
-template <typename Dst, typename Src>
-std::auto_ptr<Dst> static_cast_auto_ptr(std::auto_ptr<Src>& ptr)
-{
- return std::auto_ptr<Dst>(static_cast<Dst*>(ptr.release()));
-}
-
//
// Geometries structure comparators
//
diff --git a/tests/xmltester/BufferResultMatcher.cpp b/tests/xmltester/BufferResultMatcher.cpp
index 6813d18..108575b 100644
--- a/tests/xmltester/BufferResultMatcher.cpp
+++ b/tests/xmltester/BufferResultMatcher.cpp
@@ -70,7 +70,7 @@ BufferResultMatcher::isSymDiffAreaInTolerance(
const geom::Geometry& actualBuffer,
const geom::Geometry& expectedBuffer)
{
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
using namespace operation::overlay;
using geos::geom::BinaryOp;
@@ -101,7 +101,7 @@ BufferResultMatcher::isBoundaryHausdorffDistanceInTolerance(
const geom::Geometry& actualBuffer,
const geom::Geometry& expectedBuffer, double distance)
{
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
using geos::algorithm::distance::DiscreteHausdorffDistance;
diff --git a/tests/xmltester/SimpleWKTTester.cpp b/tests/xmltester/SimpleWKTTester.cpp
index af732e2..44643b7 100644
--- a/tests/xmltester/SimpleWKTTester.cpp
+++ b/tests/xmltester/SimpleWKTTester.cpp
@@ -40,7 +40,7 @@ int main(int /*argc*/, char** /*argv*/)
string instr;
string outstr;
PrecisionModel pm;
- GeometryFactory::unique_ptr gf = GeometryFactory::create(&pm, 10);
+ GeometryFactory::Ptr gf = GeometryFactory::create(&pm, 10);
WKTReader *r = new WKTReader(gf.get());
WKTWriter *w = new WKTWriter();
Geometry *g;
diff --git a/tests/xmltester/SingleSidedBufferResultMatcher.cpp b/tests/xmltester/SingleSidedBufferResultMatcher.cpp
index d9200cd..8481669 100644
--- a/tests/xmltester/SingleSidedBufferResultMatcher.cpp
+++ b/tests/xmltester/SingleSidedBufferResultMatcher.cpp
@@ -74,7 +74,7 @@ SingleSidedBufferResultMatcher::isBoundaryHausdorffDistanceInTolerance(
const geom::Geometry& actualBuffer,
const geom::Geometry& expectedBuffer, double distance)
{
- typedef std::auto_ptr<geom::Geometry> GeomPtr;
+ typedef std::unique_ptr<geom::Geometry> GeomPtr;
using geos::algorithm::distance::DiscreteHausdorffDistance;
diff --git a/tests/xmltester/XMLTester.cpp b/tests/xmltester/XMLTester.cpp
index d4e7d75..901f6e8 100644
--- a/tests/xmltester/XMLTester.cpp
+++ b/tests/xmltester/XMLTester.cpp
@@ -91,8 +91,8 @@ using std::runtime_error;
namespace {
-std::auto_ptr<const PreparedGeometry> prepare( const geom::Geometry *g ) {
- return std::auto_ptr<const PreparedGeometry> ( PreparedGeometryFactory::prepare(g) );
+std::unique_ptr<const PreparedGeometry> prepare( const geom::Geometry *g ) {
+ return std::unique_ptr<const PreparedGeometry> ( PreparedGeometryFactory::prepare(g) );
}
// Asymmetric Rounding Algorithm - equivalent to Java Math.round()
@@ -303,15 +303,15 @@ std::cerr << "SingleSidedBufferResultMatcher FAILED" << std::endl;
XMLTester::XMLTester()
:
- gA(0),
- gB(0),
- gT(0),
- pm(0),
- factory(0),
- wktreader(0),
- wktwriter(0),
- wkbreader(0),
- wkbwriter(0),
+ gA(nullptr),
+ gB(nullptr),
+ gT(nullptr),
+ pm(nullptr),
+ factory(nullptr),
+ wktreader(nullptr),
+ wktwriter(nullptr),
+ wkbreader(nullptr),
+ wkbwriter(nullptr),
test_predicates(0),
failed(0),
succeeded(0),
@@ -745,7 +745,7 @@ XMLTester::parseTest(const TiXmlNode* node)
{
using namespace operation::overlay;
- typedef std::auto_ptr< geom::Geometry > GeomAutoPtr;
+ typedef std::unique_ptr< geom::Geometry > GeomPtr;
int success=0; // no success by default
std::string opName;
@@ -825,7 +825,7 @@ XMLTester::parseTest(const TiXmlNode* node)
{
if (opName=="relate")
{
- std::auto_ptr<geom::IntersectionMatrix> im(gA->relate(gB));
+ std::unique_ptr<geom::IntersectionMatrix> im(gA->relate(gB));
assert(im.get());
if (im->matches(opArg3)) actual_result="true";
@@ -835,7 +835,7 @@ XMLTester::parseTest(const TiXmlNode* node)
}
else if (opName=="relatestring")
{
- std::auto_ptr<geom::IntersectionMatrix> im(gA->relate(gB));
+ std::unique_ptr<geom::IntersectionMatrix> im(gA->relate(gB));
assert(im.get());
actual_result=im->toString();
@@ -860,15 +860,15 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="intersection")
{
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
profile.start();
#ifndef USE_BINARYOP
- GeomAutoPtr gRealRes(gA->intersection(gB));
+ GeomPtr gRealRes(gA->intersection(gB));
#else
- GeomAutoPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opINTERSECTION));
+ GeomPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opINTERSECTION));
#endif
profile.stop();
@@ -886,9 +886,9 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="union")
{
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
- GeomAutoPtr gRealRes;
+ GeomPtr gRealRes;
if ( gB ) {
#ifndef USE_BINARYOP
gRealRes.reset(gA->Union(gB));
@@ -911,13 +911,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="difference")
{
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
#ifndef USE_BINARYOP
- GeomAutoPtr gRealRes(gA->difference(gB));
+ GeomPtr gRealRes(gA->difference(gB));
#else
- GeomAutoPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opDIFFERENCE));
+ GeomPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opDIFFERENCE));
#endif
gRealRes->normalize();
@@ -933,13 +933,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="symdifference")
{
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
#ifndef USE_BINARYOP
- GeomAutoPtr gRealRes(gA->symDifference(gB));
+ GeomPtr gRealRes(gA->symDifference(gB));
#else
- GeomAutoPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opSYMDIFFERENCE));
+ GeomPtr gRealRes = BinaryOp(gA, gB, overlayOp(OverlayOp::opSYMDIFFERENCE));
#endif
gRealRes->normalize();
@@ -1033,10 +1033,10 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomAutoPtr gRealRes(gT->getBoundary());
+ GeomPtr gRealRes(gT->getBoundary());
gRealRes->normalize();
if (gRes->compareTo(gRealRes.get())==0) success=1;
@@ -1053,10 +1053,10 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomAutoPtr gRealRes(gT->getCentroid());
+ GeomPtr gRealRes(gT->getCentroid());
if ( gRealRes.get() ) gRealRes->normalize();
else gRealRes.reset(factory->createPoint());
@@ -1088,10 +1088,10 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomAutoPtr gRealRes(gT->convexHull());
+ GeomPtr gRealRes(gT->convexHull());
gRealRes->normalize();
if (gRes->compareTo(gRealRes.get())==0) success=1;
@@ -1110,12 +1110,12 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
profile.start();
- GeomAutoPtr gRealRes;
+ GeomPtr gRealRes;
double dist = std::atof(opArg2.c_str());
BufferParameters params;
@@ -1147,12 +1147,12 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
profile.start();
- GeomAutoPtr gRealRes;
+ GeomPtr gRealRes;
double dist = std::atof(opArg2.c_str());
BufferParameters params ;
@@ -1192,12 +1192,12 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
profile.start();
- GeomAutoPtr gRealRes;
+ GeomPtr gRealRes;
double dist = std::atof(opArg2.c_str());
BufferParameters params;
@@ -1229,10 +1229,10 @@ XMLTester::parseTest(const TiXmlNode* node)
geom::Geometry *gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
- GeomAutoPtr gRes(parseGeometry(opRes, "expected"));
+ GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomAutoPtr gRealRes(gT->getInteriorPoint());
+ GeomPtr gRealRes(gT->getInteriorPoint());
if ( gRealRes.get() ) gRealRes->normalize();
else gRealRes.reset(factory->createPoint());
@@ -1261,7 +1261,7 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="polygonize")
{
- GeomAutoPtr gRes(wktreader->read(opRes));
+ GeomPtr gRes(wktreader->read(opRes));
gRes->normalize();
Polygonizer plgnzr;
@@ -1274,7 +1274,7 @@ XMLTester::parseTest(const TiXmlNode* node)
newgeoms->push_back((*polys)[i]);
delete polys;
- GeomAutoPtr gRealRes(factory->createGeometryCollection(newgeoms));
+ GeomPtr gRealRes(factory->createGeometryCollection(newgeoms));
gRealRes->normalize();
@@ -1289,7 +1289,7 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="linemerge")
{
- GeomAutoPtr gRes(wktreader->read(opRes));
+ GeomPtr gRes(wktreader->read(opRes));
gRes->normalize();
geom::Geometry *gT=gA;
@@ -1298,11 +1298,11 @@ XMLTester::parseTest(const TiXmlNode* node)
LineMerger merger;
merger.add(gT);
- std::auto_ptr< std::vector<geom::LineString *> > lines ( merger.getMergedLineStrings() );
+ std::unique_ptr< std::vector<geom::LineString *> > lines ( merger.getMergedLineStrings() );
std::vector<geom::Geometry *>*newgeoms = new std::vector<geom::Geometry *>(lines->begin(),
lines->end());
- GeomAutoPtr gRealRes(factory->createGeometryCollection(newgeoms));
+ GeomPtr gRealRes(factory->createGeometryCollection(newgeoms));
gRealRes->normalize();
if (gRes->compareTo(gRealRes.get())==0) success=1;
@@ -1330,9 +1330,9 @@ XMLTester::parseTest(const TiXmlNode* node)
std::cerr << "Running intersection for areatest" << std::endl;
}
#ifndef USE_BINARYOP
- GeomAutoPtr gI(gA->intersection(gB));
+ GeomPtr gI(gA->intersection(gB));
#else
- GeomAutoPtr gI = BinaryOp(gA, gB,
+ GeomPtr gI = BinaryOp(gA, gB,
overlayOp(OverlayOp::opINTERSECTION));
#endif
@@ -1347,9 +1347,9 @@ XMLTester::parseTest(const TiXmlNode* node)
}
#ifndef USE_BINARYOP
- GeomAutoPtr gDab(gA->difference(gB));
+ GeomPtr gDab(gA->difference(gB));
#else
- GeomAutoPtr gDab = BinaryOp(gA, gB,
+ GeomPtr gDab = BinaryOp(gA, gB,
overlayOp(OverlayOp::opDIFFERENCE));
#endif
@@ -1364,9 +1364,9 @@ XMLTester::parseTest(const TiXmlNode* node)
}
#ifndef USE_BINARYOP
- GeomAutoPtr gDba(gB->difference(gA));
+ GeomPtr gDba(gB->difference(gA));
#else
- GeomAutoPtr gDba = BinaryOp(gB, gA,
+ GeomPtr gDba = BinaryOp(gB, gA,
overlayOp(OverlayOp::opDIFFERENCE));
#endif
@@ -1381,9 +1381,9 @@ XMLTester::parseTest(const TiXmlNode* node)
}
#ifndef USE_BINARYOP
- GeomAutoPtr gSD(gA->symDifference(gB));
+ GeomPtr gSD(gA->symDifference(gB));
#else
- GeomAutoPtr gSD = BinaryOp(gA, gB,
+ GeomPtr gSD = BinaryOp(gA, gB,
overlayOp(OverlayOp::opSYMDIFFERENCE));
#endif
@@ -1398,9 +1398,9 @@ XMLTester::parseTest(const TiXmlNode* node)
}
#ifndef USE_BINARYOP
- GeomAutoPtr gU(gA->Union(gB));
+ GeomPtr gU(gA->Union(gB));
#else
- GeomAutoPtr gU = BinaryOp(gA, gB,
+ GeomPtr gU = BinaryOp(gA, gB,
overlayOp(OverlayOp::opUNION));
#endif
@@ -1663,7 +1663,7 @@ main(int argC, char* argV[])
* XMLTester binary ops invoked using the new BinaryOp template function.
*
* Revision 1.31 2006/04/07 13:26:38 strk
- * Use of auto_ptr<> to prevent confusing leaks in tester
+ * Use of unique_ptr<> to prevent confusing leaks in tester
*
* Revision 1.30 2006/03/22 16:01:33 strk
* indexBintree.h header split, classes renamed to match JTS
diff --git a/tests/xmltester/XMLTester.h b/tests/xmltester/XMLTester.h
index a867ed9..1b0db32 100644
--- a/tests/xmltester/XMLTester.h
+++ b/tests/xmltester/XMLTester.h
@@ -51,12 +51,12 @@ private:
geom::Geometry *gT;
bool usePrepared;
- std::auto_ptr<geom::PrecisionModel> pm;
- geom::GeometryFactory::unique_ptr factory;
- std::auto_ptr<io::WKTReader> wktreader;
- std::auto_ptr<io::WKTWriter> wktwriter;
- std::auto_ptr<io::WKBReader> wkbreader;
- std::auto_ptr<io::WKBWriter> wkbwriter;
+ std::unique_ptr<geom::PrecisionModel> pm;
+ geom::GeometryFactory::Ptr factory;
+ std::unique_ptr<io::WKTReader> wktreader;
+ std::unique_ptr<io::WKTWriter> wktwriter;
+ std::unique_ptr<io::WKBReader> wkbreader;
+ std::unique_ptr<io::WKBWriter> wkbwriter;
TiXmlDocument xml;
int verbose;
-----------------------------------------------------------------------
Summary of changes:
capi/geos_c.cpp | 2 +-
capi/geos_ts_c.cpp | 30 +++---
doc/example.cpp | 2 +-
include/geos/algorithm/Centroid.h | 4 +-
include/geos/geom/BinaryOp.h | 18 ++--
include/geos/geom/CoordinateList.h | 6 +-
include/geos/geom/CoordinateSequence.h | 4 +-
include/geos/geom/Envelope.h | 2 +-
include/geos/geom/Geometry.h | 18 ++--
include/geos/geom/GeometryCollection.h | 6 +-
include/geos/geom/GeometryFactory.h | 69 ++++++------
include/geos/geom/LineSegment.h | 4 +-
include/geos/geom/LineString.h | 12 +--
include/geos/geom/LinearRing.h | 2 +-
include/geos/geom/Point.h | 10 +-
include/geos/geom/Polygon.h | 6 +-
include/geos/geom/util/GeometryTransformer.h | 30 +++---
include/geos/geom/util/SineStarFactory.h | 2 +-
include/geos/geomgraph/GeometryGraph.h | 6 +-
include/geos/index/chain/MonotoneChain.h | 4 +-
include/geos/index/quadtree/Node.h | 14 +--
include/geos/index/strtree/AbstractSTRtree.h | 10 +-
include/geos/index/strtree/SIRtree.h | 4 +-
include/geos/index/strtree/STRtree.h | 8 +-
include/geos/linearref/LinearLocation.h | 4 +-
include/geos/noding/FastNodingValidator.h | 2 +-
include/geos/noding/GeometryNoder.h | 10 +-
include/geos/noding/snapround/HotPixel.h | 4 +-
include/geos/noding/snapround/MCIndexSnapRounder.h | 4 +-
include/geos/operation/IsSimpleOp.h | 6 +-
.../operation/buffer/BufferInputLineSimplifier.h | 6 +-
include/geos/operation/buffer/OffsetCurveBuilder.h | 4 +-
include/geos/operation/distance/DistanceOp.h | 2 +-
.../geos/operation/distance/IndexedFacetDistance.h | 2 +-
.../operation/intersection/RectangleIntersection.h | 8 +-
.../intersection/RectangleIntersectionBuilder.h | 2 +-
include/geos/operation/linemerge/LineSequencer.h | 6 +-
.../geos/operation/overlay/snap/GeometrySnapper.h | 10 +-
.../operation/overlay/snap/LineStringSnapper.h | 2 +-
.../operation/overlay/snap/SnapIfNeededOverlayOp.h | 14 +--
.../geos/operation/overlay/snap/SnapOverlayOp.h | 18 ++--
.../operation/overlay/validate/FuzzyPointLocator.h | 10 +-
.../overlay/validate/OffsetPointGenerator.h | 10 +-
include/geos/operation/relate/RelateComputer.h | 2 +-
.../geos/operation/union/CascadedPolygonUnion.h | 2 +-
include/geos/operation/union/PointGeometryUnion.h | 4 +-
include/geos/operation/union/UnaryUnionOp.h | 16 +--
.../geos/operation/valid/ConnectedInteriorTester.h | 4 +-
include/geos/precision/CommonBitsOp.h | 8 +-
include/geos/precision/GeometryPrecisionReducer.h | 16 +--
include/geos/precision/MinimumClearance.h | 4 +-
.../geos/simplify/DouglasPeuckerLineSimplifier.h | 10 +-
include/geos/simplify/DouglasPeuckerSimplifier.h | 6 +-
include/geos/simplify/LineSegmentIndex.h | 6 +-
include/geos/simplify/TaggedLineString.h | 10 +-
include/geos/simplify/TaggedLineStringSimplifier.h | 4 +-
include/geos/simplify/TaggedLinesSimplifier.h | 6 +-
.../geos/simplify/TopologyPreservingSimplifier.h | 8 +-
.../triangulate/DelaunayTriangulationBuilder.h | 4 +-
include/geos/triangulate/VoronoiDiagramBuilder.h | 12 +--
include/geos/triangulate/quadedge/QuadEdge.h | 6 +-
.../triangulate/quadedge/QuadEdgeSubdivision.h | 26 ++---
include/geos/triangulate/quadedge/Vertex.h | 22 ++--
include/geos/util/GeometricShapeFactory.h | 2 +-
src/algorithm/InteriorPointArea.cpp | 6 +-
src/geom/Geometry.cpp | 22 ++--
src/geom/GeometryCollection.cpp | 6 +-
src/geom/GeometryFactory.cpp | 40 +++----
src/geom/LineSegment.cpp | 4 +-
src/geom/LineString.cpp | 10 +-
src/geom/LinearRing.cpp | 4 +-
src/geom/Point.cpp | 6 +-
src/geom/Polygon.cpp | 4 +-
src/geom/util/GeometryTransformer.cpp | 73 ++++++-------
src/geom/util/SineStarFactory.cpp | 12 +--
src/geomgraph/GeometryGraph.cpp | 6 +-
src/geomgraph/PlanarGraph.cpp | 4 +-
src/index/chain/MonotoneChain.cpp | 4 +-
src/index/quadtree/Node.cpp | 31 +++---
src/index/quadtree/Root.cpp | 6 +-
src/index/strtree/AbstractSTRtree.cpp | 14 +--
src/index/strtree/BoundablePair.cpp | 2 +-
src/index/strtree/SIRtree.cpp | 10 +-
src/index/strtree/STRtree.cpp | 20 ++--
src/io/WKTReader.cpp | 2 +-
src/linearref/LinearLocation.cpp | 6 +-
src/noding/GeometryNoder.cpp | 12 +--
src/noding/snapround/HotPixel.cpp | 2 +-
src/noding/snapround/MCIndexSnapRounder.cpp | 2 +-
src/operation/IsSimpleOp.cpp | 2 +-
src/operation/buffer/BufferBuilder.cpp | 20 ++--
src/operation/buffer/BufferInputLineSimplifier.cpp | 8 +-
src/operation/buffer/BufferOp.cpp | 2 +-
src/operation/buffer/OffsetCurveBuilder.cpp | 24 ++---
src/operation/buffer/OffsetCurveSetBuilder.cpp | 2 +-
.../distance/FacetSequenceTreeBuilder.cpp | 6 +-
src/operation/distance/IndexedFacetDistance.cpp | 2 +-
.../intersection/RectangleIntersection.cpp | 8 +-
.../intersection/RectangleIntersectionBuilder.cpp | 6 +-
src/operation/linemerge/LineMergeGraph.cpp | 2 +-
src/operation/linemerge/LineSequencer.cpp | 4 +-
src/operation/overlay/OverlayOp.cpp | 2 +-
src/operation/overlay/snap/GeometrySnapper.cpp | 30 +++---
src/operation/overlay/snap/LineStringSnapper.cpp | 2 +-
.../overlay/snap/SnapIfNeededOverlayOp.cpp | 8 +-
src/operation/overlay/snap/SnapOverlayOp.cpp | 4 +-
.../overlay/validate/FuzzyPointLocator.cpp | 12 +--
.../overlay/validate/OffsetPointGenerator.cpp | 7 +-
.../overlay/validate/OverlayResultValidator.cpp | 14 +--
src/operation/relate/RelateComputer.cpp | 10 +-
src/operation/sharedpaths/SharedPathsOp.cpp | 2 +-
src/operation/union/CascadedPolygonUnion.cpp | 30 +++---
src/operation/union/CascadedUnion.cpp | 18 ++--
src/operation/union/PointGeometryUnion.cpp | 12 +--
src/operation/union/UnaryUnionOp.cpp | 30 +++---
src/operation/valid/ConsistentAreaTester.cpp | 4 +-
src/operation/valid/IndexedNestedRingTester.h | 2 +-
src/precision/CommonBitsOp.cpp | 22 ++--
src/precision/EnhancedPrecisionOp.cpp | 2 +-
src/precision/GeometryPrecisionReducer.cpp | 22 ++--
src/precision/MinimumClearance.cpp | 8 +-
src/simplify/DouglasPeuckerLineSimplifier.cpp | 4 +-
src/simplify/DouglasPeuckerSimplifier.cpp | 36 +++----
src/simplify/LineSegmentIndex.cpp | 13 +--
src/simplify/TaggedLineString.cpp | 12 +--
src/simplify/TaggedLineStringSimplifier.cpp | 19 ++--
src/simplify/TopologyPreservingSimplifier.cpp | 27 +++--
src/triangulate/DelaunayTriangulationBuilder.cpp | 4 +-
src/triangulate/VoronoiDiagramBuilder.cpp | 31 +++---
src/triangulate/quadedge/QuadEdge.cpp | 12 +--
src/triangulate/quadedge/QuadEdgeSubdivision.cpp | 82 +++++++--------
src/triangulate/quadedge/Vertex.cpp | 26 ++---
src/util/GeometricShapeFactory.cpp | 8 +-
tests/bigtest/TestSweepLineSpeed.cpp | 2 +-
tests/bigtest/bug234.cpp | 2 +-
.../operation/buffer/IteratedBufferStressTest.cpp | 2 +-
.../predicate/RectangleIntersectsPerfTest.cpp | 8 +-
.../CGAlgorithms/computeOrientationTest.cpp | 4 +-
tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp | 2 +-
.../algorithm/CGAlgorithms/isPointInRingTest.cpp | 2 +-
.../unit/algorithm/CGAlgorithms/signedAreaTest.cpp | 2 +-
tests/unit/algorithm/ConvexHullTest.cpp | 51 ++++-----
tests/unit/algorithm/InteriorPointAreaTest.cpp | 2 +-
tests/unit/algorithm/MinimumDiameterTest.cpp | 4 +-
tests/unit/algorithm/PointLocatorTest.cpp | 6 +-
.../unit/algorithm/RobustLineIntersectionTest.cpp | 8 +-
tests/unit/algorithm/RobustLineIntersectorTest.cpp | 8 +-
.../distance/DiscreteFrechetDistanceTest.cpp | 6 +-
.../distance/DiscreteHausdorffDistanceTest.cpp | 6 +-
tests/unit/capi/GEOSContainsTest.cpp | 8 +-
tests/unit/capi/GEOSPreparedGeometryTest.cpp | 10 +-
tests/unit/geom/CoordinateArraySequenceTest.cpp | 2 +-
tests/unit/geom/CoordinateListTest.cpp | 4 +-
tests/unit/geom/Geometry/clone.cpp | 32 +++---
tests/unit/geom/Geometry/coversTest.cpp | 20 ++--
tests/unit/geom/Geometry/equalsTest.cpp | 10 +-
tests/unit/geom/Geometry/normalize.cpp | 8 +-
tests/unit/geom/Geometry/touchesTest.cpp | 32 +++---
tests/unit/geom/GeometryComponentFilterTest.cpp | 4 +-
tests/unit/geom/GeometryFactoryTest.cpp | 16 +--
tests/unit/geom/GeometryFilterTest.cpp | 4 +-
tests/unit/geom/LineStringTest.cpp | 4 +-
tests/unit/geom/LinearRingTest.cpp | 2 +-
tests/unit/geom/MultiPointTest.cpp | 4 +-
tests/unit/geom/PointTest.cpp | 6 +-
tests/unit/geom/PolygonTest.cpp | 6 +-
.../geom/prep/PreparedGeometry/touchesTest.cpp | 4 +-
.../unit/geom/prep/PreparedGeometryFactoryTest.cpp | 2 +-
tests/unit/geom/util/GeometryExtracterTest.cpp | 4 +-
tests/unit/io/WKBReaderTest.cpp | 4 +-
tests/unit/io/WKBWriterTest.cpp | 2 +-
tests/unit/io/WKTReaderTest.cpp | 6 +-
tests/unit/io/WKTWriterTest.cpp | 6 +-
tests/unit/linearref/LengthIndexedLineTest.cpp | 4 +-
tests/unit/noding/BasicSegmentStringTest.cpp | 4 +-
tests/unit/noding/NodedSegmentStringTest.cpp | 6 +-
tests/unit/noding/OrientedCoordinateArray.cpp | 6 +-
tests/unit/noding/SegmentNodeTest.cpp | 4 +-
tests/unit/noding/SegmentPointComparatorTest.cpp | 4 +-
.../noding/snapround/MCIndexSnapRounderTest.cpp | 6 +-
tests/unit/operation/IsSimpleOpTest.cpp | 8 +-
tests/unit/operation/buffer/BufferBuilderTest.cpp | 4 +-
tests/unit/operation/buffer/BufferOpTest.cpp | 4 +-
tests/unit/operation/distance/DistanceOpTest.cpp | 6 +-
.../intersection/RectangleIntersectionTest.cpp | 2 +-
tests/unit/operation/linemerge/LineMergerTest.cpp | 2 +-
.../unit/operation/linemerge/LineSequencerTest.cpp | 2 +-
.../unit/operation/overlay/OverlayOpUnionTest.cpp | 4 +-
.../operation/overlay/snap/GeometrySnapperTest.cpp | 18 ++--
.../overlay/snap/LineStringSnapperTest.cpp | 18 ++--
.../overlay/validate/FuzzyPointLocatorTest.cpp | 2 +-
.../overlay/validate/OffsetPointGeneratorTest.cpp | 24 ++---
.../validate/OverlayResultValidatorTest.cpp | 2 +-
tests/unit/operation/polygonize/PolygonizeTest.cpp | 4 +-
.../operation/sharedpaths/SharedPathsOpTest.cpp | 2 +-
.../operation/union/CascadedPolygonUnionTest.cpp | 10 +-
tests/unit/operation/union/UnaryUnionOpTest.cpp | 4 +-
tests/unit/operation/valid/IsValidTest.cpp | 4 +-
tests/unit/operation/valid/ValidClosedRingTest.cpp | 4 +-
.../valid/ValidSelfTouchingRingFormingHoleTest.cpp | 4 +-
.../precision/GeometryPrecisionReducerTest.cpp | 6 +-
.../SimpleGeometryPrecisionReducerTest.cpp | 4 +-
.../unit/simplify/DouglasPeuckerSimplifierTest.cpp | 2 +-
.../simplify/TopologyPreservingSimplifierTest.cpp | 4 +-
tests/unit/triangulate/DelaunayTest.cpp | 4 +-
tests/unit/triangulate/VoronoiTest.cpp | 10 +-
.../quadedge/QuadEdgeSubdivisionTest.cpp | 18 ++--
tests/unit/triangulate/quadedge/QuadEdgeTest.cpp | 22 ++--
.../unit/util/UniqueCoordinateArrayFilterTest.cpp | 6 +-
tests/unit/utility.h | 17 ---
tests/xmltester/BufferResultMatcher.cpp | 4 +-
tests/xmltester/SimpleWKTTester.cpp | 2 +-
tests/xmltester/SingleSidedBufferResultMatcher.cpp | 2 +-
tests/xmltester/XMLTester.cpp | 110 ++++++++++----------
tests/xmltester/XMLTester.h | 12 +--
215 files changed, 1076 insertions(+), 1108 deletions(-)
hooks/post-receive
--
geos
More information about the geos-commits
mailing list