hydrocouplespatial.h

Go to the documentation of this file.

 
#ifndef HYDROCOUPLESPATIAL_H
#define HYDROCOUPLESPATIAL_H
 
#include "hydrocouple.h"
 
 
namespace HydroCouple
{
  namespace Spatial
  {
    class IEdge;
    class IRasterBand;
    class IPolygon;
    class IPolyhedralSurface;
 
    enum class MeshDataObjectType
    {
 
      Cell,
 
      Vertex,
 
      Edge,
 
      Face,
    };
 
    enum class NetworkDataObjectType
    {
      Node,
 
      Edge,
    };
 
    enum class SpatialDataType
    {
      Scalar,
      MultiScalar,
      Vector,
      Tensor,
    };
 
    enum class RegularGridType
    {
      Cartesian,
      Rectilinear,
      Curvilinear
    };
 
    class ISpatialReferenceSystem
    {
 
    public:
      virtual ~ISpatialReferenceSystem() = default;
 
      [[nodiscard]] virtual int authSRID() const = 0;
 
      [[nodiscard]] virtual const std::string &authName() const = 0;
 
      [[nodiscard]] virtual const std::string &srText() const = 0;
 
      [[nodiscard]] virtual HydroCouple::IUnit::DistanceUnits distanceUnits() const = 0;
    };
 
    class IEnvelope
    {
    public:
      virtual ~IEnvelope() = default;
 
      [[nodiscard]] virtual double minX() const = 0;
 
      [[nodiscard]] virtual double maxX() const = 0;
 
      [[nodiscard]] virtual double minY() const = 0;
 
      [[nodiscard]] virtual double maxY() const = 0;
 
      [[nodiscard]] virtual double minZ() const = 0;
 
      [[nodiscard]] virtual double maxZ() const = 0;
    };
 
    class IGeometry
    {
    public:
      enum class GeometryType
      {
        Geometry = 0,
        Point = 1,
        LineString = 2,
        Polygon = 3,
        Triangle = 17,
        MultiPoint = 4,
        MultiLineString = 5,
        MultiPolygon = 6,
        GeometryCollection = 7,
        CircularString = 8,
        CompoundCurve = 9,
        CurvePolygon = 10,
        MultiCurve = 11,
        MultiSurface = 12,
        Curve = 13,
        Surface = 14,
        PolyhedralSurface = 15,
        TIN = 16,
 
        GeometryZ = 1000,
        PointZ = 1001,
        LineStringZ = 1002,
        PolygonZ = 1003,
        TriangleZ = 1017,
        MultiPointZ = 1004,
        MultiLineStringZ = 1005,
        MultiPolygonZ = 1006,
        GeometryCollectionZ = 1007,
        CircularStringZ = 1008,
        CompoundCurveZ = 1009,
        CurvePolygonZ = 1010,
        MultiCurveZ = 1011,
        MultiSurfaceZ = 1012,
        CurveZ = 1013,
        SurfaceZ = 1014,
        PolyhedralSurfaceZ = 1015,
        TINZ = 1016,
 
        GeometryM = 2000,
        PointM = 2001,
        LineStringM = 2002,
        PolygonM = 2003,
        TriangleM = 2017,
        MultiPointM = 2004,
        MultiLineStringM = 2005,
        MultiPolygonM = 2006,
        GeometryCollectionM = 2007,
        CircularStringM = 2008,
        CompoundCurveM = 2009,
        CurvePolygonM = 2010,
        MultiCurveM = 2011,
        MultiSurfaceM = 2012,
        CurveM = 2013,
        SurfaceM = 2014,
        PolyhedralSurfaceM = 2015,
        TINM = 2016,
 
        GeometryZM = 3000,
        PointZM = 3001,
        LineStringZM = 3002,
        PolygonZM = 3003,
        TriangleZM = 3017,
        MultiPointZM = 3004,
        MultiLineStringZM = 3005,
        MultiPolygonZM = 3006,
        GeometryCollectionZM = 3007,
        CircularStringZM = 3008,
        CompoundCurveZM = 3009,
        CurvePolygonZM = 3010,
        MultiCurveZM = 3011,
        MultiSurfaceZM = 3012,
        CurveZM = 3013,
        SurfaceZM = 3014,
        PolyhedralSurfaceZM = 3015,
        TINZM = 3016,
      };
 
      virtual ~IGeometry() = default;
 
      [[nodiscard]] virtual const std::string &id() const = 0;
 
      [[nodiscard]] virtual unsigned int index() const = 0;
 
      [[nodiscard]] virtual int dimension() const = 0;
 
      [[nodiscard]] virtual int coordinateDimension() const = 0;
 
      [[nodiscard]] virtual GeometryType geometryType() const = 0;
 
      [[nodiscard]] virtual ISpatialReferenceSystem *spatialReferenceSystem() const = 0;
 
      [[nodiscard]] virtual IEnvelope *envelope() const = 0;
 
      [[nodiscard]] virtual std::string getWKT() const = 0;
 
      [[nodiscard]] virtual std::vector<unsigned char> getWKB() const = 0;
 
      [[nodiscard]] virtual bool isEmpty() const = 0;
 
      [[nodiscard]] virtual bool isSimple() const = 0;
 
      [[nodiscard]] virtual bool is3D() const = 0;
 
      [[nodiscard]] virtual bool isMeasured() const = 0;
 
      [[nodiscard]] virtual IGeometry *boundary() const = 0;
 
 
      [[nodiscard]] virtual bool equals(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool disjoint(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool intersects(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool touches(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool crosses(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool within(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool contains(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool overlaps(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual bool relate(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual IGeometry *locateAlong(double value) const = 0;
 
      [[nodiscard]] virtual IGeometry *locateBetween(double mStart, double mEnd) const = 0;
 
 
      [[nodiscard]] virtual double distance(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual IGeometry *buffer(double bufferDistance) const = 0;
 
      [[nodiscard]] virtual IGeometry *convexHull() const = 0;
 
      [[nodiscard]] virtual IGeometry *intersection(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual IGeometry *unionG(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual IGeometry *difference(const IGeometry &geom) const = 0;
 
      [[nodiscard]] virtual IGeometry *symmetricDifference(const IGeometry &geom) const = 0;
 
    };
 
    class IGeometryCollection : public virtual IGeometry
    {
 
    public:
      virtual ~IGeometryCollection() = default;
 
      [[nodiscard]] virtual int geometryCount() const = 0;
 
      [[nodiscard]] virtual IGeometry *geometry(int index) const = 0;
    };
 
    class IPoint : public virtual IGeometry
    {
    public:
      virtual ~IPoint() = default;
 
      [[nodiscard]] virtual double x() const = 0;
 
      [[nodiscard]] virtual double y() const = 0;
 
      [[nodiscard]] virtual double z() const = 0;
 
      [[nodiscard]] virtual double m() const = 0;
    };
 
    class IMultiPoint : public virtual IGeometryCollection
    {
 
    public:
      virtual ~IMultiPoint() = default;
 
      [[nodiscard]] virtual IPoint *point(int index) const = 0;
    };
 
    class IVertex : public virtual IPoint
    {
    public:
      virtual ~IVertex() = default;
 
      [[nodiscard]] virtual unsigned int index() const = 0;
 
      [[nodiscard]] virtual IEdge *edge() const = 0;
    };
 
    class ICurve : public virtual IGeometry
    {
 
    public:
      virtual ~ICurve() = default;
 
      [[nodiscard]] virtual double length() const = 0;
 
      [[nodiscard]] virtual IPoint *startPoint() const = 0;
 
      [[nodiscard]] virtual IPoint *endPoint() const = 0;
 
      [[nodiscard]] virtual bool isClosed() const = 0;
 
      [[nodiscard]] virtual bool isRing() const = 0;
    };
 
    class IMultiCurve : public virtual IGeometryCollection
    {
    public:
      virtual ~IMultiCurve() = default;
 
      [[nodiscard]] virtual bool isClosed() const = 0;
 
      [[nodiscard]] virtual double length() const = 0;
    };
 
    class ILineString : public virtual ICurve
    {
    public:
      virtual ~ILineString() = default;
 
      [[nodiscard]] virtual int pointCount() const = 0;
 
      [[nodiscard]] virtual IPoint *point(int index) const = 0;
    };
 
    class IMultiLineString : public virtual IMultiCurve
    {
    public:
      virtual ~IMultiLineString() = default;
 
      [[nodiscard]] virtual ILineString *lineString(int index) const = 0;
    };
 
    class ILine : public virtual ILineString
    {
    public:
      virtual ~ILine() = default;
    };
 
    class ILinearRing : public virtual ILineString
    {
    public:
      virtual ~ILinearRing() = default;
    };
 
    class IEdge
    {
    public:
      virtual ~IEdge() = default;
 
      [[nodiscard]] virtual unsigned int index() const = 0;
 
      [[nodiscard]] virtual IVertex *orig() const = 0;
 
      [[nodiscard]] virtual IVertex *dest() const = 0;
 
      [[nodiscard]] virtual IPolygon *left() const = 0;
 
      [[nodiscard]] virtual IPolygon *right() const = 0;
 
      [[nodiscard]] virtual IPolygon *face() const = 0;
 
      [[nodiscard]] virtual IEdge *rot() const = 0;
 
      [[nodiscard]] virtual IEdge *invRot() const = 0;
 
      [[nodiscard]] virtual IEdge *sym() const = 0;
 
      [[nodiscard]] virtual IEdge *origNext() const = 0;
 
      [[nodiscard]] virtual IEdge *origPrev() const = 0;
 
      [[nodiscard]] virtual IEdge *destNext() const = 0;
 
      [[nodiscard]] virtual IEdge *destPrev() const = 0;
 
      [[nodiscard]] virtual IEdge *leftNext() const = 0;
 
      [[nodiscard]] virtual IEdge *leftPrev() const = 0;
 
      [[nodiscard]] virtual IEdge *rightNext() const = 0;
 
      [[nodiscard]] virtual IEdge *rightPrev() const = 0;
    };
 
    class ISurface : public virtual IGeometry
    {
    public:
      virtual ~ISurface() = default;
 
      [[nodiscard]] virtual double area() const = 0;
 
      [[nodiscard]] virtual IPoint *centroid() const = 0;
 
      [[nodiscard]] virtual IPoint *pointOnSurface() const = 0;
 
      [[nodiscard]] virtual IMultiCurve *boundaryMultiCurve() const = 0;
    };
 
    class IMultiSurface : public virtual IGeometryCollection
    {
 
    public:
      virtual ~IMultiSurface() = default;
 
      [[nodiscard]] virtual double area() const = 0;
 
      [[nodiscard]] virtual IPoint *centroid() const = 0;
 
      [[nodiscard]] virtual IPoint *pointOnSurface() const = 0;
    };
 
    class IPolygon : public virtual ISurface
    {
    public:
      virtual ~IPolygon() = default;
 
      [[nodiscard]] virtual ILineString *exteriorRing() const = 0;
 
      [[nodiscard]] virtual int interiorRingCount() const = 0;
 
      [[nodiscard]] virtual ILineString *interiorRing(int index) const = 0;
 
      [[nodiscard]] virtual IEdge *edge() const = 0;
 
      [[nodiscard]] virtual IPolyhedralSurface *polyhedralSurface() const = 0;
    };
 
    class IMultiPolygon : public virtual IMultiSurface
    {
 
    public:
      virtual ~IMultiPolygon() = default;
 
      [[nodiscard]] virtual IPolygon *polygon(int index) const = 0;
    };
 
    class ITriangle : public virtual IPolygon
    {
    public:
      virtual ~ITriangle() = default;
 
      [[nodiscard]] virtual IVertex *vertex1() const = 0;
 
      [[nodiscard]] virtual IVertex *vertex2() const = 0;
 
      [[nodiscard]] virtual IVertex *vertex3() const = 0;
 
      [[nodiscard]] virtual IVertex *vertex(int index) const = 0;
    };
 
    class INetwork : public virtual IIdentity
    {
    public:
      virtual ~INetwork() = default;
 
      [[nodiscard]] virtual int edgeCount() const = 0;
 
      [[nodiscard]] virtual IEdge *edge(int index) const = 0;
 
      [[nodiscard]] virtual int vertexCount() const = 0;
 
      [[nodiscard]] virtual IVertex *vertex(int index) const = 0;
    };
 
    class IPolyhedralSurface : public virtual ISurface
    {
    public:
      virtual ~IPolyhedralSurface() = default;
 
      [[nodiscard]] virtual int patchCount() const = 0;
 
      [[nodiscard]] virtual IPolygon *patch(int index) const = 0;
 
      [[nodiscard]] virtual int vertexCount() const = 0;
 
      [[nodiscard]] virtual IVertex *vertex(int index) const = 0;
 
      [[nodiscard]] virtual IMultiPolygon *boundingPolygons(const IPolygon *polygon) const = 0;
 
      [[nodiscard]] virtual bool isClosed() const = 0;
    };
 
    class ITIN : public virtual IPolyhedralSurface
    {
    public:
      virtual ~ITIN() = default;
 
      [[nodiscard]] virtual ITriangle *triangle(int index) const = 0;
    };
 
    class IRaster : public virtual IIdentity
    {
 
    public:
      enum class RasterDataType
      {
        Unknown,
        Byte,
        UInt16,
        Int16,
        UInt32,
        Int32,
        Float32,
        Float64,
        CInt16,
        CInt32,
        CFloat32,
        CFloat64,
        ARGB32,
        ARGB32_Premultiplied,
      };
 
      virtual ~IRaster() = 0;
 
      [[nodiscard]] virtual int xSize() const = 0;
 
      [[nodiscard]] virtual int ySize() const = 0;
 
      [[nodiscard]] virtual int rasterBandCount() const = 0;
 
      virtual void addRasterBand(RasterDataType dataType) = 0;
 
      [[nodiscard]] virtual ISpatialReferenceSystem *spatialReferenceSystem() const = 0;
 
      virtual void geoTransformation(double *transformationMatrix) = 0;
 
      [[nodiscard]] virtual IRasterBand *getRasterBand(int bandIndex) const = 0;
    };
 
    class IRasterBand : public virtual IIdentity
    {
 
    public:
      virtual ~IRasterBand() = default;
 
      [[nodiscard]] virtual int xSize() const = 0;
 
      [[nodiscard]] virtual int ySize() const = 0;
 
      [[nodiscard]] virtual IRaster *raster() const = 0;
 
      [[nodiscard]] virtual IRaster::RasterDataType dataType() const = 0;
 
      virtual void read(int xOffset, int yOffset, int xSize, int ySize, void *image) const = 0;
 
      virtual void write(int xOffset, int yOffset, int xSize, int ySize, const void *image) = 0;
 
      [[nodiscard]] virtual double noData() const = 0;
    };
 
    class IRegularGrid2D : public virtual IIdentity
    {
    public:
      virtual ~IRegularGrid2D() = default;
 
      [[nodiscard]] virtual ISpatialReferenceSystem *spatialReferenceSystem() const = 0;
 
      [[nodiscard]] virtual RegularGridType gridType() const = 0;
 
      [[nodiscard]] virtual int numXNodes() const = 0;
 
      [[nodiscard]] virtual int numYNodes() const = 0;
 
      [[nodiscard]] virtual double xNodeLocation(int xNodeIndex, int yNodeIndex) const = 0;
 
      [[nodiscard]] virtual double yNodeLocation(int xNodeIndex, int yNodeIndex) const = 0;
 
      [[nodiscard]] virtual bool isActive(int xCellIndex, int yCellIndex) const = 0;
    };
 
    class IRegularGrid3D : public virtual IIdentity
    {
    public:
      virtual ~IRegularGrid3D() = default;
 
      [[nodiscard]] virtual ISpatialReferenceSystem *spatialReferenceSystem() const = 0;
 
      [[nodiscard]] virtual RegularGridType gridType() const = 0;
 
      [[nodiscard]] virtual int numXNodes() const = 0;
 
      [[nodiscard]] virtual int numYNodes() const = 0;
 
      [[nodiscard]] virtual int numZNodes() const = 0;
 
      [[nodiscard]] virtual double xNodeLocation(int xNodeIndex, int yNodeIndex) const = 0;
 
      [[nodiscard]] virtual double yNodeLocation(int xNodeIndex, int yNodeIndex) const = 0;
 
      [[nodiscard]] virtual double zNodeLocation(int xNodeIndex, int yNodeIndex, int zNodeIndex) const = 0;
 
      [[nodiscard]] virtual bool isActive(int xCellIndex, int yCellIndex, int zCellIndex) const = 0;
    };
 
    class IGeometryComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~IGeometryComponentDataItem() = default;
 
      [[nodiscard]] virtual IGeometry::GeometryType geometryType() const = 0;
 
      [[nodiscard]] virtual int geometryCount() const = 0;
 
      [[nodiscard]] virtual IGeometry *geometry(int geometryIndex) const = 0;
 
      [[nodiscard]] virtual HydroCouple::IDimension *geometryDimension() const = 0;
 
      [[nodiscard]] virtual HydroCouple::Spatial::IEnvelope *envelope() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int geometryDimensionIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int geometryDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int geometryDimensionLength = 1,
          std::span<const int>dimensionLength = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int geometryDimensionIndex,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int geometryDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int geometryDimensionLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
    class INetworkComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~INetworkComponentDataItem() = default;
 
      [[nodiscard]] virtual INetwork *network() const = 0;
 
      [[nodiscard]] virtual NetworkDataObjectType networkDataObjectType() const = 0;
 
      [[nodiscard]] virtual SpatialDataType networkDataType() const = 0;
 
      [[nodiscard]] virtual IDimension *edgeDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *vertexDimension() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int edgeDimensionIndexLength = 1,
          int vertexDimensionIndexLength = 1,
          std::span<const int>dimensionLengths = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int edgeDimensionIndexLength = 1,
          int vertexDimensionIndexLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
    class IPolyhedralSurfaceComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~IPolyhedralSurfaceComponentDataItem() = default;
 
      [[nodiscard]] virtual MeshDataObjectType meshDataObjectType() const = 0;
 
      [[nodiscard]] virtual SpatialDataType meshDataType() const = 0;
 
      [[nodiscard]] virtual IPolyhedralSurface *polyhedralSurface() const = 0;
 
      [[nodiscard]] virtual IDimension *patchDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *edgeDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *vertexDimension() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int patchDimensionIndex,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int patchDimensionIndex,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int patchDimensionIndexLength = 1,
          int edgeDimensionIndexLength = 1,
          int vertexDimensionIndexLength = 1,
          std::span<const int>dimensionLengths = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int patchDimensionIndex,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int patchDimensionIndex,
          int edgeDimensionIndex,
          int vertexDimensionIndex,
          std::span<const int>dimensionIndexes = {},
          int patchDimensionIndexLength = 1,
          int edgeDimensionIndexLength = 1,
          int vertexDimensionIndexLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
    class ITINComponentDataItem : public virtual IComponentDataItem,
                                  public virtual IPolyhedralSurfaceComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
      using IPolyhedralSurfaceComponentDataItem::getValue;
      using IPolyhedralSurfaceComponentDataItem::getValues;
      using IPolyhedralSurfaceComponentDataItem::setValue;
      using IPolyhedralSurfaceComponentDataItem::setValues;
 
      virtual ~ITINComponentDataItem() = default;
 
      [[nodiscard]] virtual ITIN *TIN() const = 0;
    };
 
    class IRasterComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~IRasterComponentDataItem() = default;
 
      [[nodiscard]] virtual IRaster *raster() const = 0;
 
      [[nodiscard]] virtual IDimension *xDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *yDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *bandDimension() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int xIndex,
          int yIndex,
          int bandIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int xIndex,
          int yIndex,
          int bandIndex,
          std::span<const int>dimensionIndexes = {},
          int xIndexLength = 1,
          int yIndexLength = 1,
          int bandIndexLength = 1,
          std::span<const int>dimensionLengths = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int xIndex,
          int yIndex,
          int band,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int xIndex,
          int yIndex,
          int bandIndex,
          std::span<const int>dimensionIndexes = {},
          int xIndexLength = 1,
          int yIndexLength = 1,
          int bandIndexLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
    class IRegularGrid2DComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~IRegularGrid2DComponentDataItem() = default;
 
      [[nodiscard]] virtual IRegularGrid2D *grid() const = 0;
 
      [[nodiscard]] virtual MeshDataObjectType meshDataObjectType() const = 0;
 
      [[nodiscard]] virtual IDimension *xCellDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *yCellDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *cellEdgeDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *cellVertexDimension() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int xCellIndex,
          int yCellIndex,
          int cellEdgeIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int xCellIndex,
          int yCellIndex,
          int cellEdgeIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {},
          int xCellIndexLength = 1,
          int yCellIndexLength = 1,
          int cellEdgeIndexLength = 1,
          int cellVertexIndexLength = 1,
          std::span<const int>dimensionLengths = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int xCellIndex,
          int yCellIndex,
          int cellEdgeIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int xCellIndex,
          int yCellIndex,
          int cellEdgeIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {},
          int xCellIndexLength = 1,
          int yCellIndexLength = 1,
          int cellEdgeIndexLength = 1,
          int cellVertexIndexLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
    class IRegularGrid3DComponentDataItem : public virtual IComponentDataItem
    {
 
    public:
      using IComponentDataItem::getValue;
      using IComponentDataItem::getValues;
      using IComponentDataItem::setValue;
      using IComponentDataItem::setValues;
 
      virtual ~IRegularGrid3DComponentDataItem() = default;
 
      [[nodiscard]] virtual IRegularGrid3D *grid() const = 0;
 
      [[nodiscard]] virtual MeshDataObjectType meshDataObjectType() const = 0;
 
      [[nodiscard]] virtual IDimension *xCellDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *yCellDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *zCellDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *cellFaceDimension() const = 0;
 
      [[nodiscard]] virtual IDimension *cellVertexDimension() const = 0;
 
      virtual void getValue(
          hydrocouple_variant &data,
          int xCellIndex,
          int yCellIndex,
          int zCellIndex,
          int cellFaceIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {}) const = 0;
 
      virtual void getValues(
          hydrocouple_variant *data,
          int xCellIndex,
          int yCellIndex,
          int zCellIndex,
          int cellFaceIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {},
          int xCellIndexLength = 1,
          int yCellIndexLength = 1,
          int zCellIndexLength = 1,
          int cellFaceIndexLength = 1,
          int cellVertexIndexLength = 1,
          std::span<const int>dimensionLengths = {}) const = 0;
 
      virtual void setValue(
          const hydrocouple_variant &data,
          int xCellIndex,
          int yCellIndex,
          int zCellIndex,
          int cellFaceIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {}) = 0;
 
      virtual void setValues(
          const hydrocouple_variant *data,
          int xCellIndex,
          int yCellIndex,
          int zCellIndex,
          int cellFaceIndex,
          int cellVertexIndex,
          std::span<const int>dimensionIndexes = {}, 
          int xCellIndexLength  = 1,
          int yCellIndexLength = 1,
          int zCellIndexLength  = 1,
          int cellFaceIndexLength = 1,
          int cellVertexIndexLength = 1,
          std::span<const int>dimensionLengths = {}) = 0;
    };
 
  }
}
 
#endif // HYDROCOUPLESPATIAL_H