GeometryFactory.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@keybit.net>
 * 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/export.h>
#include <geos/inline.h>
 
#include <vector>
#include <memory>
#include <cassert>
 
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 Point;
                class Polygon;
                class PrecisionModel;
        }
}
 
namespace geos {
namespace geom { // geos::geom

class GEOS_DLL GeometryFactory {
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); }
  };

        static GeometryFactory::unique_ptr create();

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

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

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

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

        static GeometryFactory::unique_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;

        //
        Geometry* toGeometry(const Envelope* envelope) const;

        const PrecisionModel* getPrecisionModel() const;

        Point* createPoint() const;

        Point* createPoint(const Coordinate& coordinate) const;

        Point* createPoint(CoordinateSequence *coordinates) const;

        Point* createPoint(const CoordinateSequence &coordinates) const;

        GeometryCollection* createGeometryCollection() const;

        Geometry* createEmptyGeometry() const;

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

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

        MultiLineString* createMultiLineString() const;

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

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

        MultiPolygon* createMultiPolygon() const;

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

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

        LinearRing* createLinearRing() const;

        LinearRing* createLinearRing(CoordinateSequence* newCoords) const;
 
        std::auto_ptr<Geometry> createLinearRing(
                        std::auto_ptr<CoordinateSequence> newCoords) const;

        LinearRing* createLinearRing(
                        const CoordinateSequence& coordinates) const;

        MultiPoint* createMultiPoint() const;

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

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

        MultiPoint* createMultiPoint(
                        const CoordinateSequence &fromCoords) const;

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

        Polygon* createPolygon() const;

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

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

        LineString* createLineString() const;

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

        LineString* createLineString(CoordinateSequence* coordinates) const;
 
        std::auto_ptr<Geometry> createLineString(
                        std::auto_ptr<CoordinateSequence> coordinates) const;

        LineString* createLineString(
                        const CoordinateSequence& coordinates) const;

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

  //
  template <class T>
        std::auto_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->getClassSortIndex();
      }
      else if ( geomClass != g->getClassSortIndex() ) {
        isHeterogeneous = true;
      }
    }
 
    // for the empty geometry, return an empty GeometryCollection
    if ( count == 0 ) {
      return std::auto_ptr<Geometry>( createGeometryCollection() );
    }
 
    // for the single geometry, return a clone
    if ( count == 1 ) {
      return std::auto_ptr<Geometry>( (*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<Geometry*> fromGeoms;
    for (T i=from; i != toofar; ++i) {
      const Geometry* g = *i;
      fromGeoms.push_back(const_cast<Geometry*>(g));
    }
    
 
    // for an heterogeneous ...
    if ( isHeterogeneous ) {
      return std::auto_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) );
    } else if ( dynamic_cast<const LineString*>(*from) ) {
      return std::auto_ptr<Geometry>( createMultiLineString(fromGeoms) );
    } else if ( dynamic_cast<const Point*>(*from) ) {
      return std::auto_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
  }

        Geometry* buildGeometry(const std::vector<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:
 
        const 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