Merge pull request #32 from estebanzimanyi/feat/values-the-wrapper-states

Hand on whatever the wrapper already states as a value

Author: estebanzimanyi

MEOS.NET.Tests/CatalogValueTypeTests.cs

@@ -0,0 +1,49 @@
+using MEOS.NET.Enums;
+using MEOS.NET.Structures;
+using MEOS.NET.Types;
+
+namespace MEOS.NET.Tests
+{
+    /// <summary>
+    /// Whatever the wrapper already states as a C# value — an enum the catalog
+    /// names, a scalar behind a MEOS typedef, a struct carried by value — the
+    /// object layer hands on as that value.
+    /// </summary>
+    [TestClass]
+    public class CatalogValueTypeTests : MeosTest
+    {
+        [TestMethod]
+        public void AnEnumArgumentIsTheEnumTheCatalogNames()
+        {
+            TJsonb temp = (TJsonb)TJsonb.In(
+                "[{\"a\": [1, 2]}@2024-12-06, {\"a\": [1, 2]}@2024-12-08]")!;
+
+            Temporal? first = temp.ArrayElement(0, true, NullHandleType.NullJsonNull);
+
+            Assert.IsNotNull(first);
+        }
+
+        [TestMethod]
+        public void AScalarBehindATypedefComesBackAsThatScalar()
+        {
+            Geo point = Geo.FromText("POINT(1 1)", 4326)!;
+
+            ulong cell = point.ToS2cellCell(10);
+
+            Assert.AreNotEqual(0UL, cell);
+        }
+
+        [TestMethod]
+        public void AStructReturnedByValueComesBackAsTheStruct()
+        {
+            TPoint trip = (TPoint)TGeomPoint.In(
+                "[POINT(0 0)@2024-12-06, POINT(2 2)@2024-12-08]")!;
+            STBox bounds = STBox.In("STBOX X((-1,-1),(3,3))")!;
+
+            MvtGeom mvt = trip.AsMvtgeom(bounds, 4096, 0, true);
+
+            Assert.AreNotEqual(IntPtr.Zero, mvt.geom);
+            Assert.IsTrue(mvt.count > 0);
+        }
+    }
+}

MEOS.NET/Functions/Meos.Native.g.cs

@@ -9213,6 +9213,24 @@ private static partial class Native
             [LibraryImport(DllPath, EntryPoint = "geo_edge_ctx_make", StringMarshalling = StringMarshalling.Utf8)]
             internal static partial IntPtr GeoEdgeCtxMake(IntPtr gs);
 
+            [LibraryImport(DllPath, EntryPoint = "geo_is_planar_linear", StringMarshalling = StringMarshalling.Utf8)]
+            [return: MarshalAs(UnmanagedType.U1)]
+            internal static partial bool GeoIsPlanarLinear(IntPtr gs);
+
+            [LibraryImport(DllPath, EntryPoint = "geo_is_point_set", StringMarshalling = StringMarshalling.Utf8)]
+            [return: MarshalAs(UnmanagedType.U1)]
+            internal static partial bool GeoIsPointSet(IntPtr gs);
+
+            [LibraryImport(DllPath, EntryPoint = "geo_meos_supported", StringMarshalling = StringMarshalling.Utf8)]
+            [return: MarshalAs(UnmanagedType.U1)]
+            internal static partial bool GeoMeosSupported(IntPtr gs);
+
+            [LibraryImport(DllPath, EntryPoint = "geo_points_covered", StringMarshalling = StringMarshalling.Utf8)]
+            internal static partial IntPtr GeoPointsCovered(IntPtr pts, IntPtr gs, [MarshalAs(UnmanagedType.U1)] bool covered);
+
+            [LibraryImport(DllPath, EntryPoint = "geo_clip_linear_geom", StringMarshalling = StringMarshalling.Utf8)]
+            internal static partial IntPtr GeoClipLinearGeom(IntPtr line, IntPtr gs, [MarshalAs(UnmanagedType.U1)] bool inside);
+
             [LibraryImport(DllPath, EntryPoint = "geo_edge_ctx_free", StringMarshalling = StringMarshalling.Utf8)]
             internal static partial void GeoEdgeCtxFree(IntPtr ctx);
 

MEOS.NET/Functions/Meos.meos_internal_geo.g.cs

@@ -252,6 +252,21 @@ public static IntPtr TgeoseqsetRestrictStbox(IntPtr ss, IntPtr box, bool border_
         public static IntPtr GeoEdgeCtxMake(IntPtr gs)
             => SafeExecution<IntPtr>(() => Native.GeoEdgeCtxMake(gs));
 
+        public static bool GeoIsPlanarLinear(IntPtr gs)
+            => SafeExecution<bool>(() => Native.GeoIsPlanarLinear(gs));
+
+        public static bool GeoIsPointSet(IntPtr gs)
+            => SafeExecution<bool>(() => Native.GeoIsPointSet(gs));
+
+        public static bool GeoMeosSupported(IntPtr gs)
+            => SafeExecution<bool>(() => Native.GeoMeosSupported(gs));
+
+        public static IntPtr GeoPointsCovered(IntPtr pts, IntPtr gs, bool covered)
+            => SafeExecution<IntPtr>(() => Native.GeoPointsCovered(pts, gs, covered));
+
+        public static IntPtr GeoClipLinearGeom(IntPtr line, IntPtr gs, bool inside)
+            => SafeExecution<IntPtr>(() => Native.GeoClipLinearGeom(line, gs, inside));
+
         public static void GeoEdgeCtxFree(IntPtr ctx)
             => SafeExecution(() => Native.GeoEdgeCtxFree(ctx));
 

MEOS.NET/Types/Geo.g.cs

@@ -96,6 +96,9 @@ public ulong ToH3indexCell(int resolution)
         public ulong ToQuadbinCell(int resolution)
             => Meos.GeoToQuadbinCell(this.Ptr, resolution);
 
+        public ulong ToS2cellCell(int level)
+            => Meos.GeoToS2cellCell(this.Ptr, level);
+
         public Set? ToSet()
             => MEOSFactory.WrapSet(Meos.GeoToSet(this.Ptr));
 

MEOS.NET/Types/Jsonb.g.cs

@@ -233,6 +233,12 @@ public bool ToBool()
         public string ToCstring()
             => Meos.JsonbToCstring(this.Ptr);
 
+        public float ToFloat4()
+            => Meos.JsonbToFloat4(this.Ptr);
+
+        public double ToFloat8()
+            => Meos.JsonbToFloat8(this.Ptr);
+
         public short ToInt16()
             => Meos.JsonbToInt16(this.Ptr);
 

MEOS.NET/Types/Raquet.g.cs

@@ -143,6 +143,25 @@ public int Width()
         public static Raquet? In(string str)
             => MEOSFactory.WrapRaquet(Meos.RaquetIn(str));
 
+        public static Raquet? Make(ulong quadbin, int width, int height, MeosPixType pixtype, double nodata, bool has_nodata, byte[] pixels)
+        {
+            GCHandle _pixels = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapRaquet(Meos.RaquetMake(quadbin, width, height, (int) pixtype, nodata, has_nodata, _pixels.AddrOfPinnedObject(), (ulong) pixels.Length));
+            }
+            finally
+            {
+                _pixels.Free();
+            }
+        }
+
+        public static MeosPixType PixtypeFromString(string str)
+            => (MeosPixType) Meos.RaquetPixtypeFromString(str);
+
+        public static ulong PixtypeSize(MeosPixType pixtype)
+            => Meos.RaquetPixtypeSize((int) pixtype);
+
         public static Raquet? Read(string path, ulong quadbin)
             => MEOSFactory.WrapRaquet(Meos.RaquetRead(path, quadbin));
 

MEOS.NET/Types/TGeo.g.cs

@@ -61,6 +61,9 @@ internal TGeo(IntPtr ptr) : base(ptr) { }
         public STBox?[] SpaceBoxes(double xsize, double ysize, double zsize, Geo sorigin, bool bitmatrix, bool border_inc)
             => MEOSFactory.WrapSTBoxArray(Meos.TgeoSpaceBoxes(this.Ptr, xsize, ysize, zsize, sorigin.Ptr, bitmatrix, border_inc));
 
+        public SpaceSplit SpaceSplit(double xsize, double ysize, double zsize, Geo sorigin, bool bitmatrix, bool border_inc)
+            => Meos.TgeoSpaceSplit(this.Ptr, xsize, ysize, zsize, sorigin.Ptr, bitmatrix, border_inc);
+
         public STBox?[] SpaceTimeBoxes(double xsize, double ysize, double zsize, Interval duration, Geo sorigin, DateTime torigin, bool bitmatrix, bool border_inc)
         {
             IntPtr _duration = Marshal.AllocHGlobal(Marshal.SizeOf<Interval>());
@@ -75,6 +78,20 @@ internal TGeo(IntPtr ptr) : base(ptr) { }
             }
         }
 
+        public SpaceTimeSplit SpaceTimeSplit(double xsize, double ysize, double zsize, Interval duration, Geo sorigin, DateTime torigin, bool bitmatrix, bool border_inc)
+        {
+            IntPtr _duration = Marshal.AllocHGlobal(Marshal.SizeOf<Interval>());
+            try
+            {
+                Marshal.StructureToPtr(duration, _duration, false);
+                return Meos.TgeoSpaceTimeSplit(this.Ptr, xsize, ysize, zsize, _duration, sorigin.Ptr, MEOSConvert.ToTimestampTz(torigin), bitmatrix, border_inc);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_duration);
+            }
+        }
+
         public STBox?[] SplitEachNStboxes(int elem_count)
             => MEOSFactory.WrapSTBoxArray(Meos.TgeoSplitEachNStboxes(this.Ptr, elem_count));
 

MEOS.NET/Types/TJsonb.g.cs

@@ -18,6 +18,9 @@ internal TJsonb(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public Temporal? ArrayElement(int idx, bool astext, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbArrayElement(this.Ptr, idx, astext, (int) null_handle));
+
         public Temporal? ArrayLength()
             => MEOSFactory.WrapTemporal(Meos.TjsonbArrayLength(this.Ptr));
 
@@ -131,6 +134,25 @@ public override string ToString()
             }
         }
 
+        public Temporal? ExtractPath(Text[] path_elems, bool astext, NullHandleType null_handle)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapTemporal(Meos.TjsonbExtractPath(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length, astext, (int) null_handle));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public Temporal? Insert(Text[] keys, Jsonb newjb, bool after)
         {
             IntPtr[] _keysValues = new IntPtr[keys.Length];
@@ -153,6 +175,9 @@ public override string ToString()
         public Temporal? MinusValue(Jsonb jsb)
             => MEOSFactory.WrapTemporal(Meos.TjsonbMinusValue(this.Ptr, jsb.Ptr));
 
+        public Temporal? ObjectField(Text key, bool astext, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbObjectField(this.Ptr, key.Ptr, astext, (int) null_handle));
+
         public string Out()
             => Meos.TjsonbOut(this.Ptr);
 
@@ -184,9 +209,21 @@ public string Out()
         public Temporal? StripNulls(bool strip_in_arrays)
             => MEOSFactory.WrapTemporal(Meos.TjsonbStripNulls(this.Ptr, strip_in_arrays));
 
+        public Temporal? ToTbool(string key, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbToTbool(this.Ptr, key, (int) null_handle));
+
+        public Temporal? ToTfloat(string key, InterpType interp, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbToTfloat(this.Ptr, key, (int) interp, (int) null_handle));
+
+        public Temporal? ToTint(string key, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbToTint(this.Ptr, key, (int) null_handle));
+
         public Temporal? ToTtext()
             => MEOSFactory.WrapTemporal(Meos.TjsonbToTtext(this.Ptr));
 
+        public Temporal? ToTtextKey(string key, NullHandleType null_handle)
+            => MEOSFactory.WrapTemporal(Meos.TjsonbToTtextKey(this.Ptr, key, (int) null_handle));
+
         public Jsonb? ValueAtTimestamptz(DateTime t, bool strict)
         {
             IntPtr _value = Marshal.AllocHGlobal(8);

MEOS.NET/Types/TPoint.g.cs

@@ -17,6 +17,9 @@ internal TPoint(IntPtr ptr) : base(ptr) { }
         public Temporal? AngularDifference()
             => MEOSFactory.WrapTemporal(Meos.TpointAngularDifference(this.Ptr));
 
+        public MvtGeom AsMvtgeom(STBox bounds, int extent, int buffer, bool clip_geom)
+            => Meos.TpointAsMvtgeom(this.Ptr, bounds.Ptr, extent, buffer, clip_geom);
+
         public Temporal? AtElevation(Span s)
             => MEOSFactory.WrapTemporal(Meos.TpointAtElevation(this.Ptr, s.Ptr));
 

MEOS.NET/Types/Text.g.cs

@@ -18,6 +18,12 @@ internal Text(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public uint Hash(uint collid)
+            => Meos.TextHash(this.Ptr, collid);
+
+        public ulong HashExtended(ulong seed, uint collid)
+            => Meos.TextHashExtended(this.Ptr, seed, collid);
+
         public Text? Initcap()
             => MEOSFactory.WrapText(Meos.TextInitcap(this.Ptr));