Carry a MEOS byte buffer and its length as one array

MEOS.NET.Tests/ByteBufferTests.cs

@@ -0,0 +1,54 @@
+using MEOS.NET.Types;
+
+namespace MEOS.NET.Tests
+{
+    /// <summary>
+    /// MEOS states the length of a buffer it answers through a pointer, and reads
+    /// one back as a pointer and a length. Both are one C# array to the caller.
+    /// </summary>
+    [TestClass]
+    public class ByteBufferTests : MeosTest
+    {
+        [TestMethod]
+        public void ASpanRoundTripsThroughItsOwnWKB()
+        {
+            Span span = FloatSpan.In("[8, 10]")!;
+
+            byte[]? wkb = span.AsWKB(0);
+
+            Assert.IsNotNull(wkb);
+            Assert.IsTrue(wkb!.Length > 0);
+
+            Span? read = Span.FromWKB(wkb);
+
+            Assert.IsNotNull(read);
+            Assert.AreEqual("[8, 10]", read!.ToString());
+        }
+
+        [TestMethod]
+        public void ATemporalValueRoundTripsThroughItsOwnWKB()
+        {
+            Temporal temp = TFloat.In("[25.5@2024-12-06, 27.5@2024-12-08]")!;
+
+            byte[]? wkb = temp.AsWKB(0);
+
+            Assert.IsNotNull(wkb);
+
+            Temporal? read = Temporal.FromWKB(wkb!);
+
+            Assert.IsNotNull(read);
+            Assert.AreEqual(temp.ToString(), read!.ToString());
+        }
+
+        [TestMethod]
+        public void TheHexFormNeedsNoLengthOfItsOwn()
+        {
+            Span span = FloatSpan.In("[8, 10]")!;
+
+            string hex = span.AsHEXWKB(0);
+
+            Assert.IsTrue(hex.Length > 0);
+            Assert.AreEqual("[8, 10]", Span.FromHEXWKB(hex)!.ToString());
+        }
+    }
+}

MEOS.NET/Types/BigIntSet.g.cs

@@ -54,5 +54,18 @@ public long[] Values()
         public static Set? In(string str)
             => MEOSFactory.WrapSet(Meos.BigintsetIn(str));
 
+        public static Set? Make(long[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapSet(Meos.BigintsetMake(_values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/Cbuffer.g.cs

@@ -21,9 +21,43 @@ public override string ToString()
         public string AsEWKT(int maxdd)
             => Meos.CbufferAsEwkt(this.Ptr, maxdd);
 
+        public string AsHEXWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                return Meos.CbufferAsHexwkb(this.Ptr, variant, _size_out);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public string AsText(int maxdd)
             => Meos.CbufferAsText(this.Ptr, maxdd);
 
+        public byte[]? AsWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                IntPtr _bytes = Meos.CbufferAsWkb(this.Ptr, variant, _size_out);
+                if (_bytes == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                byte[] _wkb = new byte[Marshal.ReadInt64(_size_out)];
+                Marshal.Copy(_bytes, _wkb, 0, _wkb.Length);
+                return _wkb;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public int Cmp(Cbuffer cb2)
             => Meos.CbufferCmp(this.Ptr, cb2.Ptr);
 
@@ -102,6 +136,19 @@ public bool Same(Cbuffer cb2)
         public static Cbuffer? FromHEXWKB(string hexwkb)
             => MEOSFactory.WrapCbuffer(Meos.CbufferFromHexwkb(hexwkb));
 
+        public static Cbuffer? FromWKB(byte[] wkb)
+        {
+            GCHandle _wkb = GCHandle.Alloc(wkb, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapCbuffer(Meos.CbufferFromWkb(_wkb.AddrOfPinnedObject(), (ulong) wkb.Length));
+            }
+            finally
+            {
+                _wkb.Free();
+            }
+        }
+
         public static Cbuffer? In(string str)
             => MEOSFactory.WrapCbuffer(Meos.CbufferIn(str));
 

MEOS.NET/Types/DateSet.g.cs

@@ -57,5 +57,18 @@ public int[] Values()
         public static Set? In(string str)
             => MEOSFactory.WrapSet(Meos.DatesetIn(str));
 
+        public static Set? Make(int[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapSet(Meos.DatesetMake(_values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/FloatSet.g.cs

@@ -69,5 +69,18 @@ public double[] Values()
         public static Set? In(string str)
             => MEOSFactory.WrapSet(Meos.FloatsetIn(str));
 
+        public static Set? Make(double[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapSet(Meos.FloatsetMake(_values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/IntSet.g.cs

@@ -57,5 +57,18 @@ public int[] Values()
         public static Set? In(string str)
             => MEOSFactory.WrapSet(Meos.IntsetIn(str));
 
+        public static Set? Make(int[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapSet(Meos.IntsetMake(_values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/Npoint.g.cs

@@ -21,9 +21,43 @@ public override string ToString()
         public string AsEWKT(int maxdd)
             => Meos.NpointAsEwkt(this.Ptr, maxdd);
 
+        public string AsHEXWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                return Meos.NpointAsHexwkb(this.Ptr, variant, _size_out);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public string AsText(int maxdd)
             => Meos.NpointAsText(this.Ptr, maxdd);
 
+        public byte[]? AsWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                IntPtr _bytes = Meos.NpointAsWkb(this.Ptr, variant, _size_out);
+                if (_bytes == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                byte[] _wkb = new byte[Marshal.ReadInt64(_size_out)];
+                Marshal.Copy(_bytes, _wkb, 0, _wkb.Length);
+                return _wkb;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public int Cmp(Npoint np2)
             => Meos.NpointCmp(this.Ptr, np2.Ptr);
 
@@ -90,6 +124,19 @@ public bool Same(Npoint np2)
         public static Npoint? FromHEXWKB(string hexwkb)
             => MEOSFactory.WrapNpoint(Meos.NpointFromHexwkb(hexwkb));
 
+        public static Npoint? FromWKB(byte[] wkb)
+        {
+            GCHandle _wkb = GCHandle.Alloc(wkb, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapNpoint(Meos.NpointFromWkb(_wkb.AddrOfPinnedObject(), (ulong) wkb.Length));
+            }
+            finally
+            {
+                _wkb.Free();
+            }
+        }
+
         public static Npoint? In(string str)
             => MEOSFactory.WrapNpoint(Meos.NpointIn(str));
 

MEOS.NET/Types/Pcpatch.g.cs

@@ -78,5 +78,18 @@ public uint Npoints()
             }
         }
 
+        public static Pcpatch? MakeCoords(uint pcid, double[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapPcpatch(Meos.PcpatchMakeCoords(pcid, _values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/Pcpoint.g.cs

@@ -44,5 +44,18 @@ public string HexOut(int maxdd)
         public static Pcpoint? HexIn(string str)
             => MEOSFactory.WrapPcpoint(Meos.PcpointHexIn(str));
 
+        public static Pcpoint? Make(uint pcid, double[] values)
+        {
+            GCHandle _values = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapPcpoint(Meos.PcpointMake(pcid, _values.AddrOfPinnedObject(), values.Length));
+            }
+            finally
+            {
+                _values.Free();
+            }
+        }
+
     }
 }

MEOS.NET/Types/Pose.g.cs

@@ -30,9 +30,43 @@ public string AsEWKT(int maxdd)
         public string AsGeopose(int conformance, int precision)
             => Meos.PoseAsGeopose(this.Ptr, conformance, precision);
 
+        public string AsHEXWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                return Meos.PoseAsHexwkb(this.Ptr, variant, _size_out);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public string AsText(int maxdd)
             => Meos.PoseAsText(this.Ptr, maxdd);
 
+        public byte[]? AsWKB(byte variant)
+        {
+            IntPtr _size_out = Marshal.AllocHGlobal(sizeof(long));
+            try
+            {
+                IntPtr _bytes = Meos.PoseAsWkb(this.Ptr, variant, _size_out);
+                if (_bytes == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                byte[] _wkb = new byte[Marshal.ReadInt64(_size_out)];
+                Marshal.Copy(_bytes, _wkb, 0, _wkb.Length);
+                return _wkb;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(_size_out);
+            }
+        }
+
         public int Cmp(Pose pose2)
             => Meos.PoseCmp(this.Ptr, pose2.Ptr);
 
@@ -138,6 +172,19 @@ public double[] Ypr()
         public static Pose? FromHEXWKB(string hexwkb)
             => MEOSFactory.WrapPose(Meos.PoseFromHexwkb(hexwkb));
 
+        public static Pose? FromWKB(byte[] wkb)
+        {
+            GCHandle _wkb = GCHandle.Alloc(wkb, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapPose(Meos.PoseFromWkb(_wkb.AddrOfPinnedObject(), (ulong) wkb.Length));
+            }
+            finally
+            {
+                _wkb.Free();
+            }
+        }
+
         public static Pose? In(string str)
             => MEOSFactory.WrapPose(Meos.PoseIn(str));