GeometryFactory.h

Go to the documentation of this file.

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
 * Copyright (C) 2006 Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: geom/GeometryFactory.java r320 (JTS-1.12)
 *
 **********************************************************************/

#ifndef GEOS_GEOM_GEOMETRYFACTORY_H
#define GEOS_GEOM_GEOMETRYFACTORY_H

#include <geos/geom/Geometry.h>
#include <geos/geom/GeometryCollection.h>
#include <geos/geom/MultiPoint.h>
#include <geos/geom/MultiLineString.h>
#include <geos/geom/MultiPolygon.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/export.h>
#include <geos/inline.h>
#include <geos/util.h>

#include <vector>
#include <memory>
#include <cassert>
#include <geos/util/IllegalArgumentException.h>

namespace geos {
namespace geom {
class CoordinateSequenceFactory;
class Coordinate;
class CoordinateSequence;
class Envelope;
class Geometry;
class GeometryCollection;
class LineString;
class LinearRing;
class MultiLineString;
class MultiPoint;
class MultiPolygon;
class Polygon;
}
}

namespace geos {
namespace geom { // geos::geom

class GEOS_DLL GeometryFactory {
private:

    struct GeometryFactoryDeleter {
        void
        operator()(GeometryFactory* p) const
        {
            p->destroy();
        }
    };

public:

    using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>;

    static GeometryFactory::Ptr create();

    static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID,
                                       CoordinateSequenceFactory* nCoordinateSequenceFactory);

    static GeometryFactory::Ptr create(CoordinateSequenceFactory* nCoordinateSequenceFactory);

    static GeometryFactory::Ptr create(const PrecisionModel* pm);

    static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID);

    static GeometryFactory::Ptr create(const GeometryFactory& gf);

    static const GeometryFactory*
    getDefaultInstance();

//Skipped a lot of list to array convertors

    Point* createPointFromInternalCoord(const Coordinate* coord,
                                        const Geometry* exemplar) const;

    std::unique_ptr<Geometry> toGeometry(const Envelope* envelope) const;

    const PrecisionModel* getPrecisionModel() const;

    std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const;

    Point* createPoint(const Coordinate& coordinate) const;

    Point* createPoint(CoordinateSequence* coordinates) const;

    Point* createPoint(const CoordinateSequence& coordinates) const;

    std::unique_ptr<GeometryCollection> createGeometryCollection() const;

    std::unique_ptr<Geometry> createEmptyGeometry() const;

    GeometryCollection* createGeometryCollection(
        std::vector<Geometry*>* newGeoms) const;

    template<typename T>
    std::unique_ptr<GeometryCollection> createGeometryCollection(
            std::vector<std::unique_ptr<T>> && newGeoms) const {
        // Can't use make_unique because constructor is protected
        return std::unique_ptr<GeometryCollection>(new GeometryCollection(Geometry::toGeometryArray(std::move(newGeoms)), *this));
    }

    GeometryCollection* createGeometryCollection(
        const std::vector<const Geometry*>& newGeoms) const;

    std::unique_ptr<MultiLineString> createMultiLineString() const;

    MultiLineString* createMultiLineString(
        std::vector<Geometry*>* newLines) const;

    MultiLineString* createMultiLineString(
        const std::vector<const Geometry*>& fromLines) const;

    std::unique_ptr<MultiLineString> createMultiLineString(
            std::vector<std::unique_ptr<LineString>> && fromLines) const;

    std::unique_ptr<MultiLineString> createMultiLineString(
            std::vector<std::unique_ptr<Geometry>> && fromLines) const;

    std::unique_ptr<MultiPolygon> createMultiPolygon() const;

    MultiPolygon* createMultiPolygon(std::vector<Geometry*>* newPolys) const;

    MultiPolygon* createMultiPolygon(
        const std::vector<const Geometry*>& fromPolys) const;

    std::unique_ptr<MultiPolygon> createMultiPolygon(
        std::vector<std::unique_ptr<Polygon>> && fromPolys) const;

    std::unique_ptr<MultiPolygon> createMultiPolygon(
            std::vector<std::unique_ptr<Geometry>> && fromPolys) const;

    std::unique_ptr<LinearRing> createLinearRing() const;

    LinearRing* createLinearRing(CoordinateSequence* newCoords) const;

    std::unique_ptr<LinearRing> createLinearRing(
        std::unique_ptr<CoordinateSequence> && newCoords) const;

    LinearRing* createLinearRing(
        const CoordinateSequence& coordinates) const;

    std::unique_ptr<MultiPoint> createMultiPoint() const;

    MultiPoint* createMultiPoint(std::vector<Geometry*>* newPoints) const;

    std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Point>> && newPoints) const;

    std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Geometry>> && newPoints) const;

    MultiPoint* createMultiPoint(
        const std::vector<const Geometry*>& fromPoints) const;

    MultiPoint* createMultiPoint(
        const CoordinateSequence& fromCoords) const;

    MultiPoint* createMultiPoint(
        const std::vector<Coordinate>& fromCoords) const;

    std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const;

    Polygon* createPolygon(LinearRing* shell,
                           std::vector<LinearRing*>* holes) const;

    std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell) const;

    std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell,
                                           std::vector<std::unique_ptr<LinearRing>> && holes) const;

    Polygon* createPolygon(const LinearRing& shell,
                           const std::vector<LinearRing*>& holes) const;

    std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;

    std::unique_ptr<LineString> createLineString(const LineString& ls) const;

    LineString* createLineString(CoordinateSequence* coordinates) const;

    std::unique_ptr<LineString> createLineString(
        std::unique_ptr<CoordinateSequence> && coordinates) const;

    LineString* createLineString(
        const CoordinateSequence& coordinates) const;

    std::unique_ptr<Geometry> createEmpty(int dimension) const;

    Geometry* buildGeometry(std::vector<Geometry*>* geoms) const;

    std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Geometry>> && geoms) const;

    std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Point>> && geoms) const;

    std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<LineString>> && geoms) const;

    std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Polygon>> && geoms) const;

    //
    template <class T>
    std::unique_ptr<Geometry>
    buildGeometry(T from, T toofar) const
    {
        bool isHeterogeneous = false;
        size_t count = 0;
        int geomClass = -1;
        for(T i = from; i != toofar; ++i) {
            ++count;
            const Geometry* g = *i;
            if(geomClass < 0) {
                geomClass = g->getSortIndex();
            }
            else if(geomClass != g->getSortIndex()) {
                isHeterogeneous = true;
            }
        }

        // for the empty geometry, return an empty GeometryCollection
        if(count == 0) {
            return std::unique_ptr<Geometry>(createGeometryCollection());
        }

        // for the single geometry, return a clone
        if(count == 1) {
            return (*from)->clone();
        }

        // Now we know it is a collection

        // FIXME:
        // Until we tweak all the createMulti* interfaces
        // to support taking iterators we'll have to build
        // a custom vector here.
        std::vector<std::unique_ptr<Geometry>> fromGeoms;
        for(T i = from; i != toofar; ++i) {
            fromGeoms.push_back((*i)->clone());
        }

        // for an heterogeneous ...
        if(isHeterogeneous) {
            return createGeometryCollection(std::move(fromGeoms));
        }

        // At this point we know the collection is not hetereogenous.
        switch((*from)->getDimension()) {
            case Dimension::A: return createMultiPolygon(std::move(fromGeoms));
            case Dimension::L: return createMultiLineString(std::move(fromGeoms));
            case Dimension::P: return createMultiPoint(std::move(fromGeoms));
            default:
                throw geos::util::IllegalArgumentException(std::string("Invalid geometry type."));
        }
    }

    Geometry* buildGeometry(const std::vector<const Geometry*>& geoms) const;

    int getSRID() const;

    const CoordinateSequenceFactory* getCoordinateSequenceFactory() const;

    Geometry* createGeometry(const Geometry* g) const;

    void destroyGeometry(Geometry* g) const;

    void destroy();

protected:

    GeometryFactory();

    GeometryFactory(const PrecisionModel* pm, int newSRID,
                    CoordinateSequenceFactory* nCoordinateSequenceFactory);

    GeometryFactory(CoordinateSequenceFactory* nCoordinateSequenceFactory);

    GeometryFactory(const PrecisionModel* pm);

    GeometryFactory(const PrecisionModel* pm, int newSRID);

    GeometryFactory(const GeometryFactory& gf);

    virtual ~GeometryFactory();

private:

    PrecisionModel precisionModel;
    int SRID;
    const CoordinateSequenceFactory* coordinateListFactory;

    mutable int _refCount;
    bool _autoDestroy;

    friend class Geometry;

    void addRef() const;
    void dropRef() const;

};

} // namespace geos::geom
} // namespace geos

#ifdef GEOS_INLINE
# include "geos/geom/GeometryFactory.inl"
#endif

#endif // ndef GEOS_GEOM_GEOMETRYFACTORY_H