Answer an array of MEOS values as the classes they are

MEOS returns many values two ways: an array of pointers (`Temporal **`,
`TInstant **`) and an array of the values themselves, walked at the struct's
own stride (`Span *`, `TBox *`, `STBox *`). Both reach the wrapper as an array
of pointers, so both wrap element by element into the class each value's own
header names, and the object layer answers `Span?[]`, `STBox?[]`,
`Temporal?[]` where it answered nothing before. That is 29 more methods:
`SpanSet.Spans`, `STBox.QuadSplit`, `Temporal.Instants`, the `bins` and
`splitNSpans` families, 607 of the model's methods against 578.

Three tests read them: the spans of a float span set come back as `FloatSpan`
printing `[8, 10]` and `[11, 12]`, the four quadrants of an STBox come back as
boxes, and the instants of a temporal float sequence come back as `TFloatInst`.

Author: estebanzimanyi

MEOS.NET.Tests/ValueArrayTests.cs

@@ -0,0 +1,52 @@
+using MEOS.NET.Types;
+
+namespace MEOS.NET.Tests
+{
+    /// <summary>
+    /// A method that answers many MEOS values answers them as the classes their
+    /// own headers name, whether MEOS returns an array of pointers or an array of
+    /// the values themselves walked at the struct's stride.
+    /// </summary>
+    [TestClass]
+    public class ValueArrayTests : MeosTest
+    {
+        [TestMethod]
+        public void TheSpansOfASpanSetComeBackAsSpans()
+        {
+            SpanSet spanset = FloatSpanSet.In("{[8, 10], [11, 12]}")!;
+
+            Span?[] spans = spanset.Spans();
+
+            Assert.AreEqual(2, spans.Length);
+            Assert.IsInstanceOfType(spans[0], typeof(FloatSpan));
+            Assert.AreEqual("[8, 10]", spans[0]!.ToString());
+            Assert.AreEqual("[11, 12]", spans[1]!.ToString());
+        }
+
+        [TestMethod]
+        public void TheQuadrantsOfABoxComeBackAsBoxes()
+        {
+            STBox box = STBox.In("STBOX X((0,0),(4,4))")!;
+
+            STBox?[] quadrants = box.QuadSplit();
+
+            Assert.AreEqual(4, quadrants.Length);
+            foreach (STBox? quadrant in quadrants)
+            {
+                StringAssert.StartsWith(quadrant!.ToString(), "STBOX X(");
+            }
+        }
+
+        [TestMethod]
+        public void TheInstantsOfASequenceComeBackAsTemporalValues()
+        {
+            Temporal temp = TFloat.In("[25.0@2024-12-06, 27.0@2024-12-07]")!;
+
+            Temporal?[] instants = temp.Instants();
+
+            Assert.AreEqual(2, instants.Length);
+            Assert.IsInstanceOfType(instants[0], typeof(TFloatInst));
+            Assert.AreEqual("25@2024-12-06 00:00:00+00", instants[0]!.ToString());
+        }
+    }
+}

MEOS.NET/Types/BigIntSpan.g.cs

@@ -15,6 +15,9 @@ internal BigIntSpan(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public Span?[] Bins(long vsize, long vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.BigintspanBins(this.Ptr, vsize, vorigin));
+
         public Span? Expand(long value)
             => MEOSFactory.WrapSpan(Meos.BigintspanExpand(this.Ptr, value));
 

MEOS.NET/Types/BigIntSpanSet.g.cs

@@ -15,6 +15,9 @@ internal BigIntSpanSet(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public Span?[] Bins(long vsize, long vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.BigintspansetBins(this.Ptr, vsize, vorigin));
+
         public long Lower()
             => Meos.BigintspansetLower(this.Ptr);
 

MEOS.NET/Types/FloatSpan.g.cs

@@ -15,6 +15,9 @@ internal FloatSpan(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out(15);
 
+        public Span?[] Bins(double vsize, double vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.FloatspanBins(this.Ptr, vsize, vorigin));
+
         public Span? Ceil()
             => MEOSFactory.WrapSpan(Meos.FloatspanCeil(this.Ptr));
 

MEOS.NET/Types/FloatSpanSet.g.cs

@@ -15,6 +15,9 @@ internal FloatSpanSet(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out(15);
 
+        public Span?[] Bins(double vsize, double vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.FloatspansetBins(this.Ptr, vsize, vorigin));
+
         public SpanSet? Ceil()
             => MEOSFactory.WrapSpanSet(Meos.FloatspansetCeil(this.Ptr));
 

MEOS.NET/Types/IntSpan.g.cs

@@ -15,6 +15,9 @@ internal IntSpan(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public Span?[] Bins(int vsize, int vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.IntspanBins(this.Ptr, vsize, vorigin));
+
         public Span? Expand(int value)
             => MEOSFactory.WrapSpan(Meos.IntspanExpand(this.Ptr, value));
 

MEOS.NET/Types/IntSpanSet.g.cs

@@ -15,6 +15,9 @@ internal IntSpanSet(IntPtr ptr) : base(ptr) { }
         public override string ToString()
             => this.Out();
 
+        public Span?[] Bins(int vsize, int vorigin)
+            => MEOSFactory.WrapSpanArray(Meos.IntspansetBins(this.Ptr, vsize, vorigin));
+
         public int Lower()
             => Meos.IntspansetLower(this.Ptr);
 

MEOS.NET/Types/STBox.g.cs

@@ -72,6 +72,9 @@ public string Out(int maxdd)
         public double Perimeter(bool spheroid)
             => Meos.StboxPerimeter(this.Ptr, spheroid);
 
+        public STBox?[] QuadSplit()
+            => MEOSFactory.WrapSTBoxArray(Meos.StboxQuadSplit(this.Ptr));
+
         public STBox? Round(int maxdd)
             => MEOSFactory.WrapSTBox(Meos.StboxRound(this.Ptr, maxdd));
 

MEOS.NET/Types/Set.g.cs

@@ -47,6 +47,15 @@ public int NumValues()
         public Set? Round(int maxdd)
             => MEOSFactory.WrapSet(Meos.SetRound(this.Ptr, maxdd));
 
+        public Span?[] Spans()
+            => MEOSFactory.WrapSpanArray(Meos.SetSpans(this.Ptr));
+
+        public Span?[] SplitEachNSpans(int elems_per_span)
+            => MEOSFactory.WrapSpanArray(Meos.SetSplitEachNSpans(this.Ptr, elems_per_span));
+
+        public Span?[] SplitNSpans(int span_count)
+            => MEOSFactory.WrapSpanArray(Meos.SetSplitNSpans(this.Ptr, span_count));
+
         public Span? ToSpan()
             => MEOSFactory.WrapSpan(Meos.SetToSpan(this.Ptr));
 

MEOS.NET/Types/SpanSet.g.cs

@@ -59,6 +59,15 @@ public int NumSpans()
         public Span?[] Spanarr()
             => MEOSFactory.WrapSpanArray(Meos.SpansetSpanarr(this.Ptr));
 
+        public Span?[] Spans()
+            => MEOSFactory.WrapSpanArray(Meos.SpansetSpans(this.Ptr));
+
+        public Span?[] SplitEachNSpans(int elems_per_span)
+            => MEOSFactory.WrapSpanArray(Meos.SpansetSplitEachNSpans(this.Ptr, elems_per_span));
+
+        public Span?[] SplitNSpans(int span_count)
+            => MEOSFactory.WrapSpanArray(Meos.SpansetSplitNSpans(this.Ptr, span_count));
+
         public Span? StartSpan()
             => MEOSFactory.WrapSpan(Meos.SpansetStartSpan(this.Ptr));