interim checkin

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -14,7 +14,6 @@ namespace PolylineAlgorithm.Benchmarks;
 /// Benchmarks for the <see cref="PolylineDecoder"/> class.
 /// </summary>
 [RankColumn]
-[ShortRunJob]
 public class PolylineDecoderBenchmark {
     private readonly Consumer _consumer = new();
 

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -15,7 +15,6 @@ namespace PolylineAlgorithm.Benchmarks;
 /// Benchmarks for the <see cref="PolylineEncoder"/> class.
 /// </summary>
 [RankColumn]
-[ShortRunJob]
 public class PolylineEncoderBenchmark {
     [Params(1, 10, 100, 1_000, 10_000, 100_000, 1_000_000)]
     public int N;

benchmarks/PolylineAlgorithm.Benchmarks/Program.cs

@@ -16,10 +16,10 @@ internal class Program {
     /// </summary>
     /// <param name="args">The command-line arguments.</param>
     static void Main(string[] args) {
-        Directory.Delete("C:\\temp\\benchmark", true);
+        //Directory.Delete("C:\\temp\\benchmark", true);
 
         BenchmarkSwitcher
             .FromAssembly(typeof(Program).Assembly)
-            .Run(args,/* new DebugInProcessConfig()*/);
+            .Run(args/*, new DebugInProcessConfig()*/);
     }
 }

src/PolylineAlgorithm.IO.Pipelines/Internal/Defaults.cs

@@ -56,6 +56,10 @@ public async Task DecodeAsync(PipeReader reader, PipeWriter writer, Cancellation
             position = Process(result, ref longitude, ref temp, ref buffer);
             reader.AdvanceTo(position);
 
+            await Formatter
+                .TryWriteAsync(writer, new Coordinate(latitude, longitude), cancellation)
+                .ConfigureAwait(false);
+
             if (result.IsCompleted) {
                 break;
             }
@@ -64,11 +68,11 @@ public async Task DecodeAsync(PipeReader reader, PipeWriter writer, Cancellation
         await CompleteAsync(reader, writer)
             .ConfigureAwait(false);
 
-        static SequencePosition Process(ReadResult result, ref int latitude, ref Memory<byte> temp, ref Memory<char> buffer) {
+        static SequencePosition Process(ReadResult result, ref int value, ref Memory<byte> temp, ref Memory<char> buffer) {
             result.Buffer.Slice(0, 6).CopyTo(temp.Span);
             Encoding.UTF8.GetChars(temp.Span, buffer.Span);
 
-            long consumed = Decode(buffer.Span, ref latitude);
+            long consumed = PolylineEncoding.Default.GetNextValue(buffer.Span, ref value);
 
             return result.Buffer.GetPosition(consumed);
         }

src/PolylineAlgorithm.IO.Pipelines/PolylineDecoder.cs

@@ -6,7 +6,6 @@
 namespace PolylineAlgorithm.IO.Pipelines;
 
 using PolylineAlgorithm.Internal;
-using PolylineAlgorithm.IO.Pipelines.Internal;
 using System;
 using System.IO.Pipelines;
 using System.Text;
@@ -49,7 +48,7 @@ public async Task EncodeAsync(PipeReader reader, PipeWriter writer, Cancellation
         static void Process(PipeWriter writer, int value, Memory<char> buffer) {
             Span<char> temp = buffer.Span;
 
-            int length = Encode(ref temp, value);
+            int length = PolylineEncoding.Default.GetChars(value, ref temp);
 
             Encoding.UTF8.GetBytes(temp[..length], writer.GetSpan(length));
 
@@ -66,24 +65,6 @@ await writer
         }
     }
 
-    private static int Encode(ref Span<char> buffer, int difference) {
-        int index = 0;
-        int rem = difference << 1;
-
-        if (difference < 0) {
-            rem = ~rem;
-        }
-
-        while (rem >= Defaults.Algorithm.Space) {
-            buffer[index++] = Convert.ToChar((Defaults.Algorithm.Space | rem & Defaults.Algorithm.UnitSeparator) + Defaults.Algorithm.QuestionMark);
-            rem >>= Defaults.Algorithm.ShiftLength;
-        }
-
-        buffer[index++] = Convert.ToChar(rem + Defaults.Algorithm.QuestionMark);
-
-        return index;
-    }
-
     public static int GetRequiredCharCount(int difference) => difference switch {
         // DO NOT CHANGE THE ORDER. We are skipping inside exclusive ranges as those are covered by previous statements.
         >= -16 and <= +15 => 1,

src/PolylineAlgorithm.IO.Pipelines/PolylineEncoder.cs

@@ -6,24 +6,27 @@
 namespace PolylineAlgorithm;
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Runtime.InteropServices;
+using System.Text;
 
 /// <summary>
 /// Represents a readonly encoded polyline string.
 /// </summary>
 [StructLayout(LayoutKind.Auto)]
 [DebuggerDisplay("Value: {ToString()}, IsEmpty: {IsEmpty}, Length: {Length}")]
 public readonly struct Polyline : IEquatable<Polyline> {
-    private readonly ReadOnlyMemory<char> _value;
+    private readonly ReadOnlySequence<char> _value;
 
     /// <summary>
     /// Creates a new <see cref="Polyline"/> structure that is empty.
     /// </summary>
     public Polyline() {
-        _value = ReadOnlyMemory<char>.Empty;
+        _value = ReadOnlySequence<char>.Empty;
     }
 
     /// <summary>
@@ -36,7 +39,7 @@ public Polyline(string value) {
             throw new ArgumentNullException(nameof(value));
         }
 
-        _value = value.AsMemory();
+        _value = new ReadOnlySequence<char>(value.AsMemory());
     }
 
     /// <summary>
@@ -49,21 +52,21 @@ public Polyline(char[] value) {
             throw new ArgumentNullException(nameof(value));
         }
 
-        _value = _value = value.AsMemory();
+        _value = new ReadOnlySequence<char>(value.AsMemory());
     }
 
     /// <summary>
     /// Creates a new <see cref="Polyline"/> structure that contains the specified readonly memory region.
     /// </summary>
     /// <param name="value">The readonly memory region to initialize the polyline with.</param>
     public Polyline(ReadOnlyMemory<char> value) {
-        _value = value;
+        _value = new ReadOnlySequence<char>(value);
     }
 
     /// <summary>
     /// Gets the span of characters in the polyline.
     /// </summary>
-    internal readonly ReadOnlyMemory<char> Value => _value;
+    internal readonly ReadOnlySequence<char> Value => _value;
 
     /// <summary>
     /// Gets a value indicating whether this <see cref="Polyline" /> is empty.
@@ -79,24 +82,57 @@ public Polyline(ReadOnlyMemory<char> value) {
     /// Copies the characters in this instance to a Unicode character array.
     /// </summary>
     /// <returns>A Unicode character array.</returns>
-    public char[] ToCharArray() => Value.ToArray();
+    public char[] CopyTo(char[] destination) {
+        if (destination is null) {
+            throw new ArgumentNullException(nameof(destination));
+        }
 
-    /// <summary>
-    /// Returns a string representation of the value of this instance.
-    /// </summary>
-    /// <returns>The string value of this <see cref="Polyline"/> object.</returns>
-    public override string ToString() => Value.ToString();
+        if(Length != destination.Length) {
+            throw new ArgumentException("", paramName: nameof(destination));
+        }
+
+        _value.CopyTo(destination);
 
-    public ReadOnlyMemory<char> AsMemory() => Value;
+        return destination;
+    }
+
+    public ReadOnlySequence<char> AsSequence() => Value;
+
+    public override string ToString() {
+        if (IsEmpty) {
+            return string.Empty;
+        }
 
-    public Polyline Append(ReadOnlyMemory<char> value) {
-        if (value.IsEmpty) {
-            return this;
+        if (Value.IsSingleSegment) {
+            return Value.FirstSpan.ToString();
+        }
+        
+        var sb = Value.Length <= int.MaxValue ? new StringBuilder(Convert.ToInt32(Value.Length)) : new StringBuilder();
+        var enumerator = Value.GetEnumerator();
+
+        while (true) {
+            if (!enumerator.MoveNext()) {
+                break;
+            }
+
+            if (enumerator.Current.IsEmpty) {
+                continue;
+            }
+
+            sb.Append(enumerator.Current);
+        }
+
+        return sb.ToString();
+    }
+
+    public bool Equals(Polyline other) {
+        if ((IsEmpty != other.IsEmpty) || (Length != other.Length)) {
+            return false;
         }
 
         long position = 0;
         var enumerator = Value.GetEnumerator();
-        var right = new SequenceReader<byte>(other.Value);
+        var right = new SequenceReader<char>(other.Value);
 
         while (true) {
             if (!enumerator.MoveNext()) {
@@ -117,6 +153,22 @@ public Polyline Append(ReadOnlyMemory<char> value) {
         return position == right.Length;
     }
 
+    public override bool Equals(object obj) {
+        return obj is Polyline other && Equals(other);
+    }
+
+    public override int GetHashCode() {
+        return Value.GetHashCode();
+    }
+
+    public static bool operator ==(Polyline left, Polyline right) {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Polyline left, Polyline right) {
+        return !(left == right);
+    }
+
     #region Factory methods
 
     /// <summary>
@@ -140,10 +192,6 @@ public Polyline Append(ReadOnlyMemory<char> value) {
     /// <returns>The <see cref="Polyline"/> value that corresponds to the specified string value.</returns>
     public static Polyline FromString(string polyline) => new(polyline);
 
-    internal void Append(IEnumerable<char> latitude, IEnumerable<char> longitude) {
-        throw new NotImplementedException();
-    }
-
     #endregion
 
     #region Explicit conversions

src/PolylineAlgorithm/Internal/PolylineSequence.cs renamed to src/PolylineAlgorithm/Internal/PolylineSegment.cs

@@ -65,6 +65,9 @@
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
 			<_Parameter1>PolylineAlgorithm.Tests</_Parameter1>
 		</AssemblyAttribute>
+		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+			<_Parameter1>PolylineAlgorithm.IO.Pipelines</_Parameter1>
+		</AssemblyAttribute>
 	</ItemGroup>
 
 	<ItemGroup>