metadata.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 METADATA_HH_INCLUDED
#define METADATA_HH_INCLUDED

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

#include "io.hpp"
#include "util.hpp"

NS_PROJ_START

namespace common {
class UnitOfMeasure;
using UnitOfMeasurePtr = std::shared_ptr<UnitOfMeasure>;
using UnitOfMeasureNNPtr = util::nn<UnitOfMeasurePtr>;
class IdentifiedObject;
} // namespace common

namespace metadata {

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

class Citation : public util::BaseObject {
  public:
    PROJ_DLL explicit Citation(const std::string &titleIn);
    PROJ_DLL Citation();
    PROJ_DLL Citation(const Citation &other);
    PROJ_DLL ~Citation();

    PROJ_DLL const util::optional<std::string> &title() PROJ_CONST_DECL;

  protected:
    PROJ_FRIEND_OPTIONAL(Citation);
    Citation &operator=(const Citation &other);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class GeographicExtent;
using GeographicExtentPtr = std::shared_ptr<GeographicExtent>;
using GeographicExtentNNPtr = util::nn<GeographicExtentPtr>;

class GeographicExtent : public util::BaseObject, public util::IComparable {
  public:
    PROJ_DLL ~GeographicExtent() override;

    // GeoAPI has a getInclusion() method. We assume that it is included for our
    // use

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

    PROJ_DLL virtual bool
    contains(const GeographicExtentNNPtr &other) const = 0;

    PROJ_DLL virtual bool
    intersects(const GeographicExtentNNPtr &other) const = 0;

    PROJ_DLL virtual GeographicExtentPtr
    intersection(const GeographicExtentNNPtr &other) const = 0;

  protected:
    GeographicExtent();

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class GeographicBoundingBox;
using GeographicBoundingBoxPtr = std::shared_ptr<GeographicBoundingBox>;
using GeographicBoundingBoxNNPtr = util::nn<GeographicBoundingBoxPtr>;

class GeographicBoundingBox : public GeographicExtent {
  public:
    PROJ_DLL ~GeographicBoundingBox() override;

    PROJ_DLL double westBoundLongitude() PROJ_CONST_DECL;
    PROJ_DLL double southBoundLatitude() PROJ_CONST_DECL;
    PROJ_DLL double eastBoundLongitude() PROJ_CONST_DECL;
    PROJ_DLL double northBoundLatitude() PROJ_CONST_DECL;

    PROJ_DLL static GeographicBoundingBoxNNPtr
    create(double west, double south, double east, double north);

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

    PROJ_DLL bool contains(const GeographicExtentNNPtr &other) const override;

    PROJ_DLL bool intersects(const GeographicExtentNNPtr &other) const override;

    PROJ_DLL GeographicExtentPtr
    intersection(const GeographicExtentNNPtr &other) const override;

  protected:
    GeographicBoundingBox(double west, double south, double east, double north);
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class TemporalExtent;
using TemporalExtentPtr = std::shared_ptr<TemporalExtent>;
using TemporalExtentNNPtr = util::nn<TemporalExtentPtr>;

class TemporalExtent : public util::BaseObject, public util::IComparable {
  public:
    PROJ_DLL ~TemporalExtent() override;

    PROJ_DLL const std::string &start() PROJ_CONST_DECL;
    PROJ_DLL const std::string &stop() PROJ_CONST_DECL;

    PROJ_DLL static TemporalExtentNNPtr create(const std::string &start,
                                               const std::string &stop);

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

    PROJ_DLL bool contains(const TemporalExtentNNPtr &other) const;

    PROJ_DLL bool intersects(const TemporalExtentNNPtr &other) const;

  protected:
    TemporalExtent(const std::string &start, const std::string &stop);
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class VerticalExtent;
using VerticalExtentPtr = std::shared_ptr<VerticalExtent>;
using VerticalExtentNNPtr = util::nn<VerticalExtentPtr>;

class VerticalExtent : public util::BaseObject, public util::IComparable {
  public:
    PROJ_DLL ~VerticalExtent() override;

    PROJ_DLL double minimumValue() PROJ_CONST_DECL;
    PROJ_DLL double maximumValue() PROJ_CONST_DECL;
    PROJ_DLL common::UnitOfMeasureNNPtr &unit() PROJ_CONST_DECL;

    PROJ_DLL static VerticalExtentNNPtr
    create(double minimumValue, double maximumValue,
           const common::UnitOfMeasureNNPtr &unitIn);

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

    PROJ_DLL bool contains(const VerticalExtentNNPtr &other) const;

    PROJ_DLL bool intersects(const VerticalExtentNNPtr &other) const;

  protected:
    VerticalExtent(double minimumValue, double maximumValue,
                   const common::UnitOfMeasureNNPtr &unitIn);
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class Extent;
using ExtentPtr = std::shared_ptr<Extent>;
using ExtentNNPtr = util::nn<ExtentPtr>;

class Extent : public util::BaseObject, public util::IComparable {
  public:
    PROJ_DLL Extent(const Extent &other);
    PROJ_DLL ~Extent() override;

    PROJ_DLL const util::optional<std::string> &description() PROJ_CONST_DECL;
    PROJ_DLL const std::vector<GeographicExtentNNPtr> &
    geographicElements() PROJ_CONST_DECL;
    PROJ_DLL const std::vector<TemporalExtentNNPtr> &
    temporalElements() PROJ_CONST_DECL;
    PROJ_DLL const std::vector<VerticalExtentNNPtr> &
    verticalElements() PROJ_CONST_DECL;

    PROJ_DLL static ExtentNNPtr
    create(const util::optional<std::string> &descriptionIn,
           const std::vector<GeographicExtentNNPtr> &geographicElementsIn,
           const std::vector<VerticalExtentNNPtr> &verticalElementsIn,
           const std::vector<TemporalExtentNNPtr> &temporalElementsIn);

    PROJ_DLL static ExtentNNPtr
    createFromBBOX(double west, double south, double east, double north,
                   const util::optional<std::string> &descriptionIn =
                       util::optional<std::string>());

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

    PROJ_DLL bool contains(const ExtentNNPtr &other) const;

    PROJ_DLL bool intersects(const ExtentNNPtr &other) const;

    PROJ_DLL ExtentPtr intersection(const ExtentNNPtr &other) const;

    PROJ_DLL static const ExtentNNPtr WORLD;

  protected:
    Extent();
    INLINED_MAKE_SHARED

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

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

class Identifier;
using IdentifierPtr = std::shared_ptr<Identifier>;
using IdentifierNNPtr = util::nn<IdentifierPtr>;

class Identifier : public util::BaseObject, public io::IWKTExportable {
  public:
    PROJ_DLL Identifier(const Identifier &other);
    PROJ_DLL ~Identifier() override;

    PROJ_DLL static IdentifierNNPtr
    create(const std::string &codeIn = std::string(),
           const util::PropertyMap &properties =
               util::PropertyMap()); // throw(InvalidValueTypeException)

    PROJ_DLL static const std::string AUTHORITY_KEY;
    PROJ_DLL static const std::string CODE_KEY;
    PROJ_DLL static const std::string CODESPACE_KEY;
    PROJ_DLL static const std::string VERSION_KEY;
    PROJ_DLL static const std::string DESCRIPTION_KEY;
    PROJ_DLL static const std::string URI_KEY;

    PROJ_DLL static const std::string EPSG;
    PROJ_DLL static const std::string OGC;

    PROJ_DLL const util::optional<Citation> &authority() PROJ_CONST_DECL;
    PROJ_DLL const std::string &code() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<std::string> &codeSpace() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<std::string> &version() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<std::string> &description() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<std::string> &uri() PROJ_CONST_DECL;

    PROJ_DLL static bool isEquivalentName(const char *a, const std::string &b);

    PROJ_DLL static bool isEquivalentName(const std::string &a,
                                          const std::string &b);

    PROJ_PRIVATE :
        static std::string
        canonicalizeName(const std::string &str);

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


  protected:
    explicit Identifier(const std::string &codeIn,
                        const util::PropertyMap &properties);

    PROJ_FRIEND_OPTIONAL(Identifier);
    INLINED_MAKE_SHARED
    Identifier &operator=(const Identifier &other) = delete;

    PROJ_FRIEND(common::IdentifiedObject);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

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

class PositionalAccuracy;
using PositionalAccuracyPtr = std::shared_ptr<PositionalAccuracy>;
using PositionalAccuracyNNPtr = util::nn<PositionalAccuracyPtr>;

class PositionalAccuracy : public util::BaseObject {
  public:
    PROJ_DLL ~PositionalAccuracy() override;

    PROJ_DLL const std::string &value() PROJ_CONST_DECL;

    PROJ_DLL static PositionalAccuracyNNPtr create(const std::string &valueIn);

  protected:
    explicit PositionalAccuracy(const std::string &valueIn);
    INLINED_MAKE_SHARED

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

} // namespace metadata

NS_PROJ_END

#endif //  METADATA_HH_INCLUDED