crs.hpp

/******************************************************************************
 *
 * Project:  PROJ
 * Purpose:  ISO19111:2018 implementation
 * Author:   Even Rouault <even dot rouault at spatialys dot com>
 *
 ******************************************************************************
 * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#ifndef CRS_HH_INCLUDED
#define CRS_HH_INCLUDED

#include <memory>
#include <string>
#include <vector>

#include "common.hpp"
#include "coordinateoperation.hpp"
#include "coordinatesystem.hpp"
#include "datum.hpp"
#include "io.hpp"
#include "util.hpp"

NS_PROJ_START

namespace crs {

// ---------------------------------------------------------------------------

class GeographicCRS;
using GeographicCRSPtr = std::shared_ptr<GeographicCRS>;
using GeographicCRSNNPtr = util::nn<GeographicCRSPtr>;

class VerticalCRS;
using VerticalCRSPtr = std::shared_ptr<VerticalCRS>;
using VerticalCRSNNPtr = util::nn<VerticalCRSPtr>;

class BoundCRS;
using BoundCRSPtr = std::shared_ptr<BoundCRS>;
using BoundCRSNNPtr = util::nn<BoundCRSPtr>;

// ---------------------------------------------------------------------------

class CRS;
using CRSPtr = std::shared_ptr<CRS>;
using CRSNNPtr = util::nn<CRSPtr>;

class CRS : public common::ObjectUsage, public io::IWKTExportable {
  public:
    PROJ_DLL ~CRS() override;

    // Non-standard

    PROJ_DLL GeodeticCRSPtr extractGeodeticCRS() const;
    PROJ_DLL GeographicCRSPtr extractGeographicCRS() const;
    PROJ_DLL VerticalCRSPtr extractVerticalCRS() const;
    PROJ_DLL CRSNNPtr
    createBoundCRSToWGS84IfPossible(io::DatabaseContextPtr dbContext) const;
    PROJ_DLL CRSNNPtr stripVerticalComponent() const;

    PROJ_DLL virtual CRSNNPtr shallowClone() const = 0;

    PROJ_DLL const BoundCRSPtr &canonicalBoundCRS() PROJ_CONST_DECL;

    PROJ_PRIVATE :
        const GeodeticCRS *
        extractGeodeticCRSRaw() const;

  protected:
    CRS();
    CRS(const CRS &other);
    friend class BoundCRS;
    void setCanonicalBoundCRS(const BoundCRSNNPtr &boundCRS);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class SingleCRS : public CRS {
  public:
    PROJ_DLL ~SingleCRS() override;

    PROJ_DLL const datum::DatumPtr &datum() PROJ_CONST_DECL;
    PROJ_DLL const datum::DatumEnsemblePtr &datumEnsemble() PROJ_CONST_DECL;
    PROJ_DLL const cs::CoordinateSystemNNPtr &
    coordinateSystem() PROJ_CONST_DECL;

    PROJ_PRIVATE :
        void
        exportDatumOrDatumEnsembleToWkt(io::WKTFormatter *formatter)
            const; // throw(io::FormattingException)

  protected:
    SingleCRS(const datum::DatumPtr &datumIn,
              const datum::DatumEnsemblePtr &datumEnsembleIn,
              const cs::CoordinateSystemNNPtr &csIn);
    SingleCRS(const SingleCRS &other);

    bool _isEquivalentTo(const util::IComparable *other,
                         util::IComparable::Criterion criterion =
                             util::IComparable::Criterion::STRICT) const;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    SingleCRS &operator=(const SingleCRS &other) = delete;
};

using SingleCRSPtr = std::shared_ptr<SingleCRS>;
using SingleCRSNNPtr = util::nn<SingleCRSPtr>;

// ---------------------------------------------------------------------------

class GeodeticCRS;
using GeodeticCRSPtr = std::shared_ptr<GeodeticCRS>;
using GeodeticCRSNNPtr = util::nn<GeodeticCRSPtr>;

class GeodeticCRS : virtual public SingleCRS, public io::IPROJStringExportable {
  public:
    PROJ_DLL ~GeodeticCRS() override;

    PROJ_DLL const datum::GeodeticReferenceFramePtr &datum() PROJ_CONST_DECL;

    PROJ_DLL const datum::PrimeMeridianNNPtr &primeMeridian() PROJ_CONST_DECL;
    PROJ_DLL const datum::EllipsoidNNPtr &ellipsoid() PROJ_CONST_DECL;

    // coordinateSystem() returns either a EllipsoidalCS, SphericalCS or
    // CartesianCS

    PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> &
    velocityModel() PROJ_CONST_DECL;

    // Non-standard

    PROJ_DLL bool isGeocentric() PROJ_CONST_DECL;

    PROJ_DLL static GeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFrameNNPtr &datum,
           const cs::SphericalCSNNPtr &cs);

    PROJ_DLL static GeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFrameNNPtr &datum,
           const cs::CartesianCSNNPtr &cs);

    PROJ_DLL static GeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFramePtr &datum,
           const datum::DatumEnsemblePtr &datumEnsemble,
           const cs::SphericalCSNNPtr &cs);

    PROJ_DLL static GeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFramePtr &datum,
           const datum::DatumEnsemblePtr &datumEnsemble,
           const cs::CartesianCSNNPtr &cs);

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

    PROJ_DLL static const GeodeticCRSNNPtr EPSG_4978; // WGS 84 Geocentric

    PROJ_PRIVATE :
        void
        addDatumInfoToPROJString(io::PROJStringFormatter *formatter) const;

    void addGeocentricUnitConversionIntoPROJString(
        io::PROJStringFormatter *formatter) const;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)


  protected:
    GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn,
                const datum::DatumEnsemblePtr &datumEnsembleIn,
                const cs::EllipsoidalCSNNPtr &csIn);
    GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn,
                const datum::DatumEnsemblePtr &datumEnsembleIn,
                const cs::SphericalCSNNPtr &csIn);
    GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn,
                const datum::DatumEnsemblePtr &datumEnsembleIn,
                const cs::CartesianCSNNPtr &csIn);
    GeodeticCRS(const GeodeticCRS &other);
    INLINED_MAKE_SHARED

    static GeodeticCRSNNPtr createEPSG_4978();

  private:
    PROJ_OPAQUE_PRIVATE_DATA

    GeodeticCRS &operator=(const GeodeticCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class GeographicCRS : public GeodeticCRS {
  public:
    PROJ_DLL ~GeographicCRS() override;

    PROJ_DLL const cs::EllipsoidalCSNNPtr &coordinateSystem() PROJ_CONST_DECL;

    // Non-standard
    PROJ_DLL static GeographicCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFrameNNPtr &datum,
           const cs::EllipsoidalCSNNPtr &cs);
    PROJ_DLL static GeographicCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::GeodeticReferenceFramePtr &datum,
           const datum::DatumEnsemblePtr &datumEnsemble,
           const cs::EllipsoidalCSNNPtr &cs);

    PROJ_DLL bool is2DPartOf3D(const GeographicCRSNNPtr &other) PROJ_CONST_DECL;

    PROJ_DLL static const GeographicCRSNNPtr EPSG_4267; // NAD27
    PROJ_DLL static const GeographicCRSNNPtr EPSG_4269; // NAD83
    PROJ_DLL static const GeographicCRSNNPtr EPSG_4326; // WGS 84 2D
    PROJ_DLL static const GeographicCRSNNPtr OGC_CRS84; // CRS84 (Long, Lat)
    PROJ_DLL static const GeographicCRSNNPtr EPSG_4807; // NTF Paris
    PROJ_DLL static const GeographicCRSNNPtr EPSG_4979; // WGS 84 3D

    PROJ_DLL CRSNNPtr shallowClone() const override;

    PROJ_PRIVATE :
        void
        addAngularUnitConvertAndAxisSwap(
            io::PROJStringFormatter *formatter) const;

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)


  protected:
    GeographicCRS(const datum::GeodeticReferenceFramePtr &datumIn,
                  const datum::DatumEnsemblePtr &datumEnsembleIn,
                  const cs::EllipsoidalCSNNPtr &csIn);
    GeographicCRS(const GeographicCRS &other);
    INLINED_MAKE_SHARED

    static GeographicCRSNNPtr createEPSG_4267();
    static GeographicCRSNNPtr createEPSG_4269();
    static GeographicCRSNNPtr createEPSG_4326();
    static GeographicCRSNNPtr createOGC_CRS84();
    static GeographicCRSNNPtr createEPSG_4807();
    static GeographicCRSNNPtr createEPSG_4979();

  private:
    PROJ_OPAQUE_PRIVATE_DATA

    GeographicCRS &operator=(const GeographicCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class VerticalCRS : virtual public SingleCRS, public io::IPROJStringExportable {
  public:
    PROJ_DLL ~VerticalCRS() override;

    PROJ_DLL const datum::VerticalReferenceFramePtr datum() const;
    PROJ_DLL const cs::VerticalCSNNPtr coordinateSystem() const;
    PROJ_DLL const std::vector<operation::TransformationNNPtr> &
    geoidModel() PROJ_CONST_DECL;
    PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> &
    velocityModel() PROJ_CONST_DECL;

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL static VerticalCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::VerticalReferenceFrameNNPtr &datumIn,
           const cs::VerticalCSNNPtr &csIn);

    PROJ_DLL static VerticalCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::VerticalReferenceFramePtr &datumIn,
           const datum::DatumEnsemblePtr &datumEnsembleIn,
           const cs::VerticalCSNNPtr &csIn);

    PROJ_DLL CRSNNPtr shallowClone() const override;

    PROJ_PRIVATE :
        void
        addLinearUnitConvert(io::PROJStringFormatter *formatter) const;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)


  protected:
    VerticalCRS(const datum::VerticalReferenceFramePtr &datumIn,
                const datum::DatumEnsemblePtr &datumEnsembleIn,
                const cs::VerticalCSNNPtr &csIn);
    VerticalCRS(const VerticalCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    VerticalCRS &operator=(const VerticalCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class DerivedCRS : virtual public SingleCRS {
  public:
    PROJ_DLL ~DerivedCRS() override;

    PROJ_DLL const SingleCRSNNPtr &baseCRS() PROJ_CONST_DECL;
    PROJ_DLL const operation::ConversionNNPtr derivingConversion() const;

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;
    PROJ_PRIVATE :
        const operation::ConversionNNPtr &
        derivingConversionRef() PROJ_CONST_DECL;

  protected:
    DerivedCRS(const SingleCRSNNPtr &baseCRSIn,
               const operation::ConversionNNPtr &derivingConversionIn,
               const cs::CoordinateSystemNNPtr &cs);
    DerivedCRS(const DerivedCRS &other);

    void setDerivingConversionCRS();

    void baseExportToPROJString(
        io::PROJStringFormatter *formatter) const; // throw(FormattingException)

    void baseExportToWKT(
        io::WKTFormatter *&formatter, const std::string &keyword,
        const std::string &baseKeyword) const; // throw(FormattingException)

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedCRS &operator=(const DerivedCRS &other) = delete;
};

using DerivedCRSPtr = std::shared_ptr<DerivedCRS>;
using DerivedCRSNNPtr = util::nn<DerivedCRSPtr>;

// ---------------------------------------------------------------------------

class ProjectedCRS;
using ProjectedCRSPtr = std::shared_ptr<ProjectedCRS>;
using ProjectedCRSNNPtr = util::nn<ProjectedCRSPtr>;

class ProjectedCRS final : public DerivedCRS, public io::IPROJStringExportable {
  public:
    PROJ_DLL ~ProjectedCRS() override;

    PROJ_DLL const GeodeticCRSNNPtr &baseCRS() PROJ_CONST_DECL;
    PROJ_DLL const cs::CartesianCSNNPtr &coordinateSystem() PROJ_CONST_DECL;

    PROJ_DLL static ProjectedCRSNNPtr
    create(const util::PropertyMap &properties,
           const GeodeticCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::CartesianCSNNPtr &csIn);

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

    PROJ_PRIVATE :
        void
        addUnitConvertAndAxisSwap(io::PROJStringFormatter *formatter,
                                  bool axisSpecFound) const;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)


  protected:
    ProjectedCRS(const GeodeticCRSNNPtr &baseCRSIn,
                 const operation::ConversionNNPtr &derivingConversionIn,
                 const cs::CartesianCSNNPtr &csIn);
    ProjectedCRS(const ProjectedCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    ProjectedCRS &operator=(const ProjectedCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class TemporalCRS;
using TemporalCRSPtr = std::shared_ptr<TemporalCRS>;
using TemporalCRSNNPtr = util::nn<TemporalCRSPtr>;

class TemporalCRS : virtual public SingleCRS {
  public:
    PROJ_DLL ~TemporalCRS() override;

    PROJ_DLL const datum::TemporalDatumNNPtr datum() const;

    PROJ_DLL const cs::TemporalCSNNPtr coordinateSystem() const;

    PROJ_DLL static TemporalCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::TemporalDatumNNPtr &datumIn,
           const cs::TemporalCSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    TemporalCRS(const datum::TemporalDatumNNPtr &datumIn,
                const cs::TemporalCSNNPtr &csIn);
    TemporalCRS(const TemporalCRS &other);

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    TemporalCRS &operator=(const TemporalCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class EngineeringCRS;
using EngineeringCRSPtr = std::shared_ptr<EngineeringCRS>;
using EngineeringCRSNNPtr = util::nn<EngineeringCRSPtr>;

class EngineeringCRS : virtual public SingleCRS {
  public:
    PROJ_DLL ~EngineeringCRS() override;

    PROJ_DLL const datum::EngineeringDatumNNPtr datum() const;

    PROJ_DLL static EngineeringCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::EngineeringDatumNNPtr &datumIn,
           const cs::CoordinateSystemNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    EngineeringCRS(const datum::EngineeringDatumNNPtr &datumIn,
                   const cs::CoordinateSystemNNPtr &csIn);
    EngineeringCRS(const EngineeringCRS &other);

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    EngineeringCRS &operator=(const EngineeringCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class ParametricCRS;
using ParametricCRSPtr = std::shared_ptr<ParametricCRS>;
using ParametricCRSNNPtr = util::nn<ParametricCRSPtr>;

class ParametricCRS : virtual public SingleCRS {
  public:
    PROJ_DLL ~ParametricCRS() override;

    PROJ_DLL const datum::ParametricDatumNNPtr datum() const;

    PROJ_DLL const cs::ParametricCSNNPtr coordinateSystem() const;

    PROJ_DLL static ParametricCRSNNPtr
    create(const util::PropertyMap &properties,
           const datum::ParametricDatumNNPtr &datumIn,
           const cs::ParametricCSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    ParametricCRS(const datum::ParametricDatumNNPtr &datumIn,
                  const cs::ParametricCSNNPtr &csIn);
    ParametricCRS(const ParametricCRS &other);

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    ParametricCRS &operator=(const ParametricCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class CompoundCRS;
using CompoundCRSPtr = std::shared_ptr<CompoundCRS>;
using CompoundCRSNNPtr = util::nn<CompoundCRSPtr>;

class CompoundCRS final : public CRS, public io::IPROJStringExportable {
  public:
    PROJ_DLL ~CompoundCRS() override;

    PROJ_DLL const std::vector<CRSNNPtr> &
    componentReferenceSystems() PROJ_CONST_DECL;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL static CompoundCRSNNPtr
    create(const util::PropertyMap &properties,
           const std::vector<CRSNNPtr> &components);

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    // relaxed: standard say SingleCRSNNPtr
    explicit CompoundCRS(const std::vector<CRSNNPtr> &components);
    CompoundCRS(const CompoundCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    CompoundCRS &operator=(const CompoundCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class BoundCRS final : public CRS, public io::IPROJStringExportable {
  public:
    PROJ_DLL ~BoundCRS() override;

    PROJ_DLL const CRSNNPtr &baseCRS() PROJ_CONST_DECL;
    PROJ_DLL CRSNNPtr baseCRSWithCanonicalBoundCRS() const;

    PROJ_DLL const CRSNNPtr &hubCRS() PROJ_CONST_DECL;
    PROJ_DLL const operation::TransformationNNPtr &
    transformation() PROJ_CONST_DECL;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL static BoundCRSNNPtr
    create(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn,
           const operation::TransformationNNPtr &transformationIn);

    PROJ_DLL static BoundCRSNNPtr
    createFromTOWGS84(const CRSNNPtr &baseCRSIn,
                      const std::vector<double> &TOWGS84Parameters);

    PROJ_DLL static BoundCRSNNPtr
    createFromNadgrids(const CRSNNPtr &baseCRSIn, const std::string &filename);

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    BoundCRS(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn,
             const operation::TransformationNNPtr &transformationIn);
    BoundCRS(const BoundCRS &other);
    INLINED_MAKE_SHARED

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    BoundCRSNNPtr shallowCloneAsBoundCRS() const;
    bool isTOWGS84Compatible() const;
    std::string getHDatumPROJ4GRIDS() const;
    std::string getVDatumPROJ4GRIDS() const;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    BoundCRS &operator=(const BoundCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class DerivedGeodeticCRS;
using DerivedGeodeticCRSPtr = std::shared_ptr<DerivedGeodeticCRS>;
using DerivedGeodeticCRSNNPtr = util::nn<DerivedGeodeticCRSPtr>;

class DerivedGeodeticCRS final : public GeodeticCRS, public DerivedCRS {
  public:
    PROJ_DLL ~DerivedGeodeticCRS() override;

    PROJ_DLL const GeodeticCRSNNPtr baseCRS() const;

    PROJ_DLL static DerivedGeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const GeodeticCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::CartesianCSNNPtr &csIn);

    PROJ_DLL static DerivedGeodeticCRSNNPtr
    create(const util::PropertyMap &properties,
           const GeodeticCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::SphericalCSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn,
                       const operation::ConversionNNPtr &derivingConversionIn,
                       const cs::CartesianCSNNPtr &csIn);
    DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn,
                       const operation::ConversionNNPtr &derivingConversionIn,
                       const cs::SphericalCSNNPtr &csIn);
    DerivedGeodeticCRS(const DerivedGeodeticCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedGeodeticCRS &operator=(const DerivedGeodeticCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class DerivedGeographicCRS;
using DerivedGeographicCRSPtr = std::shared_ptr<DerivedGeographicCRS>;
using DerivedGeographicCRSNNPtr = util::nn<DerivedGeographicCRSPtr>;

class DerivedGeographicCRS final : public GeographicCRS, public DerivedCRS {
  public:
    PROJ_DLL ~DerivedGeographicCRS() override;

    PROJ_DLL const GeodeticCRSNNPtr baseCRS() const;

    PROJ_DLL static DerivedGeographicCRSNNPtr
    create(const util::PropertyMap &properties,
           const GeodeticCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::EllipsoidalCSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    DerivedGeographicCRS(const GeodeticCRSNNPtr &baseCRSIn,
                         const operation::ConversionNNPtr &derivingConversionIn,
                         const cs::EllipsoidalCSNNPtr &csIn);
    DerivedGeographicCRS(const DerivedGeographicCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedGeographicCRS &operator=(const DerivedGeographicCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class DerivedProjectedCRS;
using DerivedProjectedCRSPtr = std::shared_ptr<DerivedProjectedCRS>;
using DerivedProjectedCRSNNPtr = util::nn<DerivedProjectedCRSPtr>;

class DerivedProjectedCRS final : public DerivedCRS,
                                  public io::IPROJStringExportable {
  public:
    PROJ_DLL ~DerivedProjectedCRS() override;

    PROJ_DLL const ProjectedCRSNNPtr baseCRS() const;

    PROJ_DLL static DerivedProjectedCRSNNPtr
    create(const util::PropertyMap &properties,
           const ProjectedCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::CoordinateSystemNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    DerivedProjectedCRS(const ProjectedCRSNNPtr &baseCRSIn,
                        const operation::ConversionNNPtr &derivingConversionIn,
                        const cs::CoordinateSystemNNPtr &csIn);
    DerivedProjectedCRS(const DerivedProjectedCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedProjectedCRS &operator=(const DerivedProjectedCRS &other) = delete;
};

// ---------------------------------------------------------------------------

class DerivedVerticalCRS;
using DerivedVerticalCRSPtr = std::shared_ptr<DerivedVerticalCRS>;
using DerivedVerticalCRSNNPtr = util::nn<DerivedVerticalCRSPtr>;

class DerivedVerticalCRS final : public VerticalCRS, public DerivedCRS {
  public:
    PROJ_DLL ~DerivedVerticalCRS() override;

    PROJ_DLL const VerticalCRSNNPtr baseCRS() const;

    PROJ_DLL static DerivedVerticalCRSNNPtr
    create(const util::PropertyMap &properties,
           const VerticalCRSNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const cs::VerticalCSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    DerivedVerticalCRS(const VerticalCRSNNPtr &baseCRSIn,
                       const operation::ConversionNNPtr &derivingConversionIn,
                       const cs::VerticalCSNNPtr &csIn);
    DerivedVerticalCRS(const DerivedVerticalCRS &other);

    void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedVerticalCRS &operator=(const DerivedVerticalCRS &other) = delete;
};

// ---------------------------------------------------------------------------

template <class DerivedCRSTraits>
class DerivedCRSTemplate final : public DerivedCRSTraits::BaseType,
                                 public DerivedCRS {
  protected:
    typedef typename DerivedCRSTraits::BaseType BaseType;
    typedef typename DerivedCRSTraits::CSType CSType;

  public:
    PROJ_DLL ~DerivedCRSTemplate() override;

    typedef typename util::nn<std::shared_ptr<DerivedCRSTemplate>> NNPtr;
    typedef util::nn<std::shared_ptr<BaseType>> BaseNNPtr;
    typedef util::nn<std::shared_ptr<CSType>> CSNNPtr;

    PROJ_DLL const BaseNNPtr baseCRS() const;

    PROJ_DLL static NNPtr
    create(const util::PropertyMap &properties, const BaseNNPtr &baseCRSIn,
           const operation::ConversionNNPtr &derivingConversionIn,
           const CSNNPtr &csIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    PROJ_DLL CRSNNPtr shallowClone() const override;

  protected:
    DerivedCRSTemplate(const BaseNNPtr &baseCRSIn,
                       const operation::ConversionNNPtr &derivingConversionIn,
                       const CSNNPtr &csIn);
    DerivedCRSTemplate(const DerivedCRSTemplate &other);

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    DerivedCRSTemplate &operator=(const DerivedCRSTemplate &other) = delete;
};

// ---------------------------------------------------------------------------

struct DerivedEngineeringCRSTraits {
    typedef EngineeringCRS BaseType;
    typedef cs::CoordinateSystem CSType;
    // old x86_64-w64-mingw32-g++ has issues with static variables. use method
    // instead
    inline static const std::string &CRSName();
    inline static const std::string &WKTKeyword();
    inline static const std::string &WKTBaseKeyword();
    static const bool wkt2_2018_only = true;
};

#ifdef DOXYGEN_ENABLED
class DerivedEngineeringCRS
    : public DerivedCRSTemplate<DerivedEngineeringCRSTraits> {};
#else
using DerivedEngineeringCRS = DerivedCRSTemplate<DerivedEngineeringCRSTraits>;
#endif

#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
extern template class DerivedCRSTemplate<DerivedEngineeringCRSTraits>;
#endif

using DerivedEngineeringCRSPtr = std::shared_ptr<DerivedEngineeringCRS>;
using DerivedEngineeringCRSNNPtr = util::nn<DerivedEngineeringCRSPtr>;

// ---------------------------------------------------------------------------

struct DerivedParametricCRSTraits {
    typedef ParametricCRS BaseType;
    typedef cs::ParametricCS CSType;
    // old x86_64-w64-mingw32-g++ has issues with static variables. use method
    // instead
    inline static const std::string &CRSName();
    inline static const std::string &WKTKeyword();
    inline static const std::string &WKTBaseKeyword();
    static const bool wkt2_2018_only = false;
};

#ifdef DOXYGEN_ENABLED
class DerivedParametricCRS
    : public DerivedCRSTemplate<DerivedParametricCRSTraits> {};
#else
using DerivedParametricCRS = DerivedCRSTemplate<DerivedParametricCRSTraits>;
#endif

#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
extern template class DerivedCRSTemplate<DerivedParametricCRSTraits>;
#endif

using DerivedParametricCRSPtr = std::shared_ptr<DerivedParametricCRS>;
using DerivedParametricCRSNNPtr = util::nn<DerivedParametricCRSPtr>;

// ---------------------------------------------------------------------------

struct DerivedTemporalCRSTraits {
    typedef TemporalCRS BaseType;
    typedef cs::TemporalCS CSType;
    // old x86_64-w64-mingw32-g++ has issues with static variables. use method
    // instead
    inline static const std::string &CRSName();
    inline static const std::string &WKTKeyword();
    inline static const std::string &WKTBaseKeyword();
    static const bool wkt2_2018_only = false;
};

#ifdef DOXYGEN_ENABLED
class DerivedTemporalCRS : public DerivedCRSTemplate<DerivedTemporalCRSTraits> {
};
#else
using DerivedTemporalCRS = DerivedCRSTemplate<DerivedTemporalCRSTraits>;
#endif

#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
extern template class DerivedCRSTemplate<DerivedTemporalCRSTraits>;
#endif

using DerivedTemporalCRSPtr = std::shared_ptr<DerivedTemporalCRS>;
using DerivedTemporalCRSNNPtr = util::nn<DerivedTemporalCRSPtr>;

// ---------------------------------------------------------------------------

} // namespace crs

NS_PROJ_END

#endif //  CRS_HH_INCLUDED