geometry.hpp

#pragma once

#include <ciso646>
#include <vector>
#include <memory>
#include <simo/shapes_fwd.hpp>
#include <simo/geom/detail/bounds.hpp>
#include <simo/geom/detail/types.hpp>
#include <simo/geom/detail/utils.hpp>
#include <simo/exceptions.hpp>

namespace simo
{
namespace shapes
{

template <typename T>
class basic_geometry
{
  public:
    geometry_type geom_type() const noexcept
    {
        return static_cast<const T*>(this)->geom_type_();
    }

    std::string tagged_text() const noexcept
    {
        switch (geom_type())
        {
            case geometry_type::POINT:
                return "Point";
            case geometry_type::POINTZ:
                return "Point Z";
            case geometry_type::POINTM:
                return "Point M";
            case geometry_type::POINTZM:
                return "Point ZM";
            case geometry_type::MULTIPOINT:
                return "MultiPoint";
            case geometry_type::MULTIPOINTZ:
                return "MultiPoint Z";
            case geometry_type::MULTIPOINTM:
                return "MultiPoint M";
            case geometry_type::MULTIPOINTZM:
                return "MultiPoint ZM";
            case geometry_type::LINESTRING:
                return "LineString";
            case geometry_type::LINESTRINGZ:
                return "LineString Z";
            case geometry_type::LINESTRINGM:
                return "LineString M";
            case geometry_type::LINESTRINGZM:
                return "LineString ZM";
            case geometry_type::MULTILINESTRING:
                return "MultiLineString";
            case geometry_type::MULTILINESTRINGZ:
                return "MultiLineString Z";
            case geometry_type::MULTILINESTRINGM:
                return "MultiLineString M";
            case geometry_type::MULTILINESTRINGZM:
                return "MultiLineString ZM";
            case geometry_type::POLYGON:
                return "Polygon";
            case geometry_type::POLYGONZ:
                return "Polygon Z";
            case geometry_type::POLYGONM:
                return "Polygon M";
            case geometry_type::POLYGONZM:
                return "Polygon ZM";
            case geometry_type::MULTIPOLYGON:
                return "MultiPolygon";
            case geometry_type::MULTIPOLYGONZ:
                return "MultiPolygon Z";
            case geometry_type::MULTIPOLYGONM:
                return "MultiPolygon M";
            case geometry_type::MULTIPOLYGONZM:
                return "MultiPolygon ZM";
            case geometry_type::GEOMETRYCOLLECTION:
                return "GeometryCollection";
            case geometry_type::GEOMETRYCOLLECTIONZ:
                return "GeometryCollection Z";
            case geometry_type::GEOMETRYCOLLECTIONM:
                return "GeometryCollection M";
            case geometry_type::GEOMETRYCOLLECTIONZM:
                return "GeometryCollection ZM";
            default:
                return "Geometry";
        }
    }

    dimension_type dim() const noexcept
    {
        int value = static_cast<int>(geom_type());
        if (value >= 1000 and value < 2000)
        {
            return dimension_type::XYZ;
        }
        if (value >= 2000 and value < 3000)
        {
            return dimension_type::XYM;
        }
        if (value >= 3000)
        {
            return dimension_type::XYZM;
        }
        return dimension_type::XY;
    }

    size_t ndim() const noexcept
    {
        switch (dim())
        {
            case dimension_type::XYZM:
                return 4;
            case dimension_type::XYZ:
            case dimension_type::XYM:
                return 3;
            default:
                return 2;
        }
    }

    void throw_for_invalid() const
    {
        return static_cast<const T*>(this)->throw_for_invalid_();
    }

    bool is_closed() const noexcept
    {
        return static_cast<const T*>(this)->is_closed_();
    }

    bool is_valid() const noexcept
    {
        try
        {
            throw_for_invalid();
        }
        catch (const exceptions::geometry_error& e)
        {
            return false;
        }
        return true;
    }

    bounds_t bounds() const
    {
        return static_cast<const T*>(this)->bounds_();
    }

    bool has_z() const noexcept
    {
        int value = static_cast<int>(geom_type());
        return (value >= 1000 and value < 2000) or value >= 3000;
    }

    bool has_m() const noexcept
    {
        int value = static_cast<int>(geom_type());
        return value >= 2000;
    }

    // json

    static T from_json(const std::string& json)
    {
        return T::from_json_(json);
    }

    std::string json(std::int32_t precision = -1) const
    {
        return static_cast<const T*>(this)->json_(precision);
    }

    // wkt

    static T from_wkt(const std::string& wkt)
    {
        return T::from_wkt_(wkt);
    }

    std::string wkt(std::int32_t precision = -1) const
    {
        return static_cast<const T*>(this)->wkt_(precision);
    }
};

}  // namespace shapes
}  // namespace simo