hydrocouplespatialwkb.h

Go to the documentation of this file.

 
#ifndef HYDROCOUPLESPATIALWKB_H
#define HYDROCOUPLESPATIALWKB_H
 
#include <stdint.h>
#include <type_traits>
 
union WKBGeometry;
union WKBGeometryZ;
union WKBGeometryM;
union WKBGeometryZM;
 
struct Point
{
    double x; 
    double y; 
};
 
struct PointZ
{
    double x; 
    double y; 
    double z; 
};
 
struct PointM
{
    double x; 
    double y; 
    double m; 
};
 
struct PointZM
{
    double x; 
    double y; 
    double z; 
    double m; 
};
 
struct LinearRing
{
    uint32_t numPoints;
    Point *points;
};
 
struct LinearRingZ
{
    uint32_t numPoints;
    PointZ *points;
};
 
struct LinearRingM
{
    uint32_t numPoints;
    PointM *points;
};
 
struct LinearRingZM
{
    uint32_t numPoints;
    PointZM *points;
};
 
enum class WKBByteOrder : uint8_t
{
  wkbXDR = 0, 
  wkbNDR = 1  
};
 
enum class WKBGeometryType : uint32_t
{
  wkbPoint = 1,
  wkbLineString = 2,
  wkbPolygon = 3,
  wkbTriangle = 17,
  wkbMultiPoint = 4,
  wkbMultiLineString = 5,
  wkbMultiPolygon = 6,
  wkbGeometryCollection = 7,
  wkbPolyhedralSurface = 15,
  wkbTIN = 16,
  wkbPointZ = 1001,
  wkbLineStringZ = 1002,
  wkbPolygonZ = 1003,
  wkbTriangleZ = 1017,
  wkbMultiPointZ = 1004,
  wkbMultiLineStringZ = 1005,
  wkbMultiPolygonZ = 1006,
  wkbGeometryCollectionZ = 1007,
  wkbPolyhedralSurfaceZ = 1015,
  wkbTINZ = 1016,
  wkbPointM = 2001,
  wkbLineStringM = 2002,
  wkbPolygonM = 2003,
  wkbTriangleM = 2017,
  wkbMultiPointM = 2004,
  wkbMultiLineStringM = 2005,
  wkbMultiPolygonM = 2006,
  wkbGeometryCollectionM = 2007,
  wkbPolyhedralSurfaceM = 2015,
  wkbTINM = 2016,
  wkbPointZM = 3001,
  wkbLineStringZM = 3002,
  wkbPolygonZM = 3003,
  wkbTriangleZM = 3017,
  wkbMultiPointZM = 3004,
  wkbMultiLineStringZM = 3005,
  wkbMultiPolygonZM = 3006,
  wkbGeometryCollectionZM = 3007,
  wkbPolyhedralSurfaceZM = 3015,
  wkbTinZM = 3016,
};
 
struct WKBPoint
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1;
    Point point;
};
 
struct WKBPointZ
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1001;
    PointZ point;
};
 
struct WKBPointM
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2001;
    PointM point;
};
 
struct WKBPointZM
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3001;
    PointZM point;
};
 
struct WKBLineString
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2;
    uint32_t numPoints;
    Point *points;
};
 
struct WKBLineStringZ
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1002;
    uint32_t numPoints;
    PointZ *points;
};
 
struct WKBLineStringM
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2002;
    uint32_t numPoints;
    PointM *points;
};
 
struct WKBLineStringZM
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3002;
    uint32_t numPoints;
    PointZM *points;
};
 
struct WKBPolygon
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3;
    uint32_t numRings;
    LinearRing *rings;
};
 
struct WKBPolygonZ
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1003;
    uint32_t numRings;
    LinearRingZ *rings;
};
 
struct WKBPolygonM
{
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2003;
    uint32_t numRings;
    LinearRingM *rings;
};
 
struct WKBPolygonZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3003;
    uint32_t numRings;
    LinearRingZM *rings;
};
 
struct WKBTriangle {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 17;
    uint32_t numRings;
    LinearRing *rings;
};
 
struct WKBTriangleZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1017;
    uint32_t numRings;
    LinearRingZ *rings;
};
 
struct WKBTriangleM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2017;
    uint32_t numRings;
    LinearRingM *rings;
};
 
struct WKBTriangleZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3017;
    uint32_t numRings;
    LinearRingZM *rings;
};
 
struct WKBPolyhedralSurface {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 15;
    uint32_t numPolygons;
    WKBPolygon *polygons;
};
 
struct WKBPolyhedralSurfaceZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=1015;
    uint32_t numPolygons;
    WKBPolygonZ *polygons;
};
 
struct WKBPolyhedralSurfaceM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=2015;
    uint32_t numPolygons;
    WKBPolygonM *polygons;
};
 
struct WKBPolyhedralSurfaceZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=3015;
    uint32_t numPolygons;
    WKBPolygonZM *polygons;
};
 
struct WKBTIN {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 16;
    uint32_t numPolygons;
    WKBPolygon *polygons;
};
 
struct WKBTINZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=1016;
    uint32_t numPolygons;
    WKBPolygonZ *polygons;
};
 
struct WKBTINM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=2016;
    uint32_t numPolygons;
    WKBPolygonM *polygons;
};
 
struct WKBTINZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=3016;
    uint32_t numPolygons;
    WKBPolygonZM *polygons;
};
 
struct WKBMultiPoint {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=4;
    uint32_t numPoints;
    WKBPoint *points;
};
 
struct WKBMultiPointZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=1004;
    uint32_t numPoints;
    WKBPointZ *points;
};
 
struct WKBMultiPointM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=2004;
    uint32_t numPoints;
    WKBPointM *points;
};
 
struct WKBMultiPointZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType=3004;
    uint32_t numPoints;
    WKBPointZM *points;
};
 
struct WKBMultiLineString {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 5;
    uint32_t numLineStrings;
    WKBLineString *lineStrings;
};
 
struct WKBMultiLineStringZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1005;
    uint32_t numLineStrings;
    WKBLineStringZ *lineStrings;
};
 
struct WKBMultiLineStringM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2005;
    uint32_t numLineStrings;
    WKBLineStringM *lineStrings;
};
 
struct WKBMultiLineStringZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3005;
    uint32_t numLineStrings;
    WKBLineStringZM *lineStrings;
};
 
struct WKBMultiPolygon {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 6;
    uint32_t numPolygons;
    WKBPolygon *polygons;
};
 
struct WKBMultiPolygonZ {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 1006;
    uint32_t numPolygons;
    WKBPolygonZ *polygons;
};
 
struct WKBMultiPolygonM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 2006;
    uint32_t numPolygons;
    WKBPolygonM *polygons;
};
 
struct WKBMultiPolygonZM {
    WKBByteOrder byteOrder;
    static constexpr uint32_t wkbType = 3006;
    uint32_t numPolygons;
    WKBPolygonZM *polygons;
};
 
struct WKBGeometryCollection {
    WKBByteOrder byte_order;
    static constexpr uint32_t wkbType = 7;
    uint32_t numGeometries;
    WKBGeometry *geometries;
};
 
struct WKBGeometryCollectionZ {
    WKBByteOrder byte_order;
    static constexpr uint32_t wkbType = 1007;
    uint32_t numGeometries;
    WKBGeometryZ *geometries;
};
 
struct WKBGeometryCollectionM {
    WKBByteOrder byte_order;
    static constexpr uint32_t wkbType = 2007;
    uint32_t numGeometries;
    WKBGeometryM *geometries;
};
 
struct WKBGeometryCollectionZM {
    WKBByteOrder byte_order;
    static constexpr uint32_t wkbType = 3007;
    uint32_t numGeometries;
    WKBGeometryZM *geometries;
};
 
union WKBGeometry
{
    WKBPoint point;
    WKBLineString linestring;
    WKBPolygon polygon;
    WKBTriangle triangle;
    WKBPolyhedralSurface polyhedralsurface;
    WKBTIN tin;
    WKBMultiPoint mpoint;
    WKBMultiLineString mlinestring;
    WKBMultiPolygon mpolygon;
    WKBGeometryCollection collection;
};
 
union WKBGeometryZ {
 
    WKBPointZ pointz;
    WKBLineStringZ linestringz;
    WKBPolygonZ polygonz;
    WKBTriangleZ trianglez;
    WKBPolyhedralSurfaceZ Polyhedralsurfacez;
    WKBTINZ tinz;
    WKBMultiPointZ mpointz;
    WKBMultiLineStringZ mlinestringz;
    WKBMultiPolygonZ mpolygonz;
    WKBGeometryCollectionZ collectionz;
};
 
union WKBGeometryM
{
    WKBPointM pointm;
    WKBLineStringM linestringm;
    WKBPolygonM polygonm;
    WKBTriangleM trianglem;
    WKBPolyhedralSurfaceM Polyhedralsurfacem;
    WKBTINM tinm;
    WKBMultiPointM mpointm;
    WKBMultiLineStringM mlinestringm;
    WKBMultiPolygonM mpolygonm;
    WKBGeometryCollectionM collectionm;
};
 
union WKBGeometryZM
{
    WKBPointZM pointzm;
    WKBLineStringZM linestringzm;
    WKBPolygonZM polygonzm;
    WKBTriangleZM trianglezm;
    WKBPolyhedralSurfaceZM Polyhedralsurfacezm;
    WKBTINZM tinzm;
    WKBMultiPointZM mpointzm;
    WKBMultiLineStringZM mlinestringzm;
    WKBMultiPolygonZM mpolygonzm;
    WKBGeometryCollectionZM collectionzm;
};
 
// ============================================================================
// Structure-of-Arrays (SoA) coordinate buffers for cache-efficient bulk processing.
// These provide non-owning views into contiguous coordinate component arrays,
// enabling SIMD-friendly iteration over individual coordinate dimensions.
// ============================================================================
 
struct CoordinateBuffer2D
{
    double *x;        
    double *y;        
    uint32_t count;   
};
 
struct CoordinateBuffer3D
{
    double *x;        
    double *y;        
    double *z;        
    uint32_t count;   
};
 
struct CoordinateBufferM
{
    double *x;        
    double *y;        
    double *m;        
    uint32_t count;   
};
 
struct CoordinateBuffer3DM
{
    double *x;        
    double *y;        
    double *z;        
    double *m;        
    uint32_t count;   
};
 
// ============================================================================
// Compile-time type property assertions
// ============================================================================
 
static_assert(std::is_trivially_copyable_v<Point>, "Point must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PointZ>, "PointZ must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PointM>, "PointM must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PointZM>, "PointZM must be trivially copyable");
static_assert(std::is_trivially_copyable_v<LinearRing>, "LinearRing must be trivially copyable");
static_assert(std::is_trivially_copyable_v<CoordinateBuffer2D>, "CoordinateBuffer2D must be trivially copyable");
static_assert(std::is_trivially_copyable_v<CoordinateBuffer3D>, "CoordinateBuffer3D must be trivially copyable");
static_assert(std::is_trivially_copyable_v<CoordinateBuffer3DM>, "CoordinateBuffer3DM must be trivially copyable");
 
static_assert(std::is_standard_layout_v<Point>, "Point must be standard layout");
static_assert(std::is_standard_layout_v<PointZ>, "PointZ must be standard layout");
static_assert(std::is_standard_layout_v<PointM>, "PointM must be standard layout");
static_assert(std::is_standard_layout_v<PointZM>, "PointZM must be standard layout");
static_assert(std::is_standard_layout_v<CoordinateBuffer2D>, "CoordinateBuffer2D must be standard layout");
static_assert(std::is_standard_layout_v<CoordinateBuffer3D>, "CoordinateBuffer3D must be standard layout");
static_assert(std::is_standard_layout_v<CoordinateBuffer3DM>, "CoordinateBuffer3DM must be standard layout");
 
static_assert(sizeof(Point) == 2 * sizeof(double), "Point must have no padding");
static_assert(sizeof(PointZ) == 3 * sizeof(double), "PointZ must have no padding");
static_assert(sizeof(PointM) == 3 * sizeof(double), "PointM must have no padding");
static_assert(sizeof(PointZM) == 4 * sizeof(double), "PointZM must have no padding");
 
#endif // HYDROCOUPLESPATIALWKB_H