Introduce new this[int,object] to allow to differentiate from this[int,int] to mean 'Until the last value of the string', which was previously overloaded on the value zero for 'end'

Author: migueldeicaza

NStack/NStack.csproj

@@ -5,7 +5,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard1.5</TargetFramework>
     <PackageId>NStack.Core</PackageId>
-    <PackageVersion>0.6</PackageVersion>
+    <PackageVersion>0.7</PackageVersion>
     <Authors>Miguel de Icaza</Authors>
     <PackageLicenseUrl>https://github.com/migueldeicaza/NStack/blob/master/LICENSE.md</PackageLicenseUrl>
     <Owners>Miguel de Icaza</Owners>
@@ -19,7 +19,7 @@ It starts with a new string type that is focused on Unicode code-points as oppos
     <ReleaseVersion>0.3</ReleaseVersion>
     <PackageReleaseNotes>* Renamed some methods to match the equivalent methods in Char.
 * Introduced Substring (int start)
-* Typo fix</PackageReleaseNotes>
+* Introduced difference between this [int start, int end] and this [int start, object end] the latter used to mean "until the end", replacing '0' as the previous value for "until the end".</PackageReleaseNotes>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

NStack/strings/ustring.cs

@@ -850,20 +850,21 @@ public static ustring Make (byte [] buffer, int start, int count)
 		/// Returns a slice of the ustring delimited by the [start, end) range.  If the range is invalid, the return is the Empty string.
 		/// </summary>
 		/// <param name="start">Start index, this value is inclusive.   If the value is negative, the value is added to the length, allowing this parameter to count to count from the end of the string.</param>
-		/// <param name="end">End index, this value is exclusive.   If the value is negative, the value is added to the length, plus one, allowing this parameter to count from the end of the string.   If the value is zero, the end is computed as the last index of the string.</param>
+		/// <param name="iend">End index, this value is exclusive.   If the value is negative, the value is added to the length, plus one, allowing this parameter to count from the end of the string.</param>
 		/// <remarks>
 		/// <para>
 		/// Some examples given the string "1234567890":
 		/// </para>
 		/// <para>The range [0, 4] produces "1234"</para>
 		/// <para>The range [8, 10] produces "90"</para>
-		/// <para>The range [8, 0] produces "90"</para>
-		/// <para>The range [-2, 0] produces "90"</para>
+		/// <para>The range [8, null] produces "90"</para>
+		/// <para>The range [-2, null] produces "90"</para>
 		/// <para>The range [8, 9] produces "9"</para>
 		/// <para>The range [-4, -1] produces "789"</para>
-		/// <para>The range [-4, 0] produces "7890"</para>
-		/// <para>The range [-4, 0] produces "7890"</para>
+		/// <para>The range [-4, null] produces "7890"</para>
+		/// <para>The range [-4, null] produces "7890"</para>
 		/// <para>The range [-9, -3] produces "234567"</para>
+		/// <para>The range [0, 0] produces the empty string</para>
 		/// <para>
 		///   This indexer does not raise exceptions for invalid indexes, instead the value 
 		///   returned is the ustring.Empty value:
@@ -874,16 +875,18 @@ public static ustring Make (byte [] buffer, int start, int count)
 		/// <para>
 		///   The range [-100, 0] produces ustring.Empty
 		/// </para>
+		/// <para>
+		///   To simulate the optional end boundary, use the indexer that takes the
+		///   object parameter and pass a null to it.   For example, to fetch all
+		///   elements from the position five until the end, use [5, null]
+		/// </para>
 		/// </remarks>
 		public ustring this [int start, int end] {
 			get {
 				int size = Length;
-				if (end < 0) {
-					if (end == 0)
-						end = size;
-					else
-						end = size + end;
-				}
+				if (end < 0)
+					end = size + end;
+				
 				if (start < 0)
 					start = size + start;
 
@@ -895,6 +898,57 @@ public static ustring Make (byte [] buffer, int start, int count)
 			}
 		}
 
+		/// <summary>
+		/// Returns a slice of the ustring delimited by the [start, last-element-of-the-string range.  If the range is invalid, the return is the Empty string.
+		/// </summary>
+		/// <param name="start">Start index, this value is inclusive.   If the value is negative, the value is added to the length, allowing this parameter to count to count from the end of the string.</param>
+		/// <param name="end">This value is expected to be null to indicate that it should be the last element of the string.</param>
+		/// <remarks>
+		/// <para>
+		/// This is a companion indexer to the indexer that takes two integers, it only exists
+		/// to provide the optional end argument to mean "until the end", and to make the code
+		/// that uses indexer look familiar, without having to resort to another API.
+		/// 
+		/// Some examples given the string "1234567890":
+		/// </para>
+		/// <para>The range [8, null] produces "90"</para>
+		/// <para>The range [-2, null] produces "90"</para>
+		/// <para>The range [8, 9] produces "9"</para>
+		/// <para>The range [-4, -1] produces "789"</para>
+		/// <para>The range [-4, null] produces "7890"</para>
+		/// <para>The range [-4, null] produces "7890"</para>
+		/// <para>The range [-9, -3] produces "234567"</para>
+		/// <para>
+		///   This indexer does not raise exceptions for invalid indexes, instead the value 
+		///   returned is the ustring.Empty value:
+		/// </para>
+		/// <para>
+		///   The range [100, 200] produces the ustring.Empty
+		/// </para>
+		/// <para>
+		///   The range [-100, 0] produces ustring.Empty
+		/// </para>
+		/// <para>
+		///   To simulate the optional end boundary, use the indexer that takes the
+		///   object parameter and pass a null to it.   For example, to fetch all
+		///   elements from the position five until the end, use [5, null]
+		/// </para>
+		/// </remarks>
+		public ustring this [int start, object end] {
+			get {
+				int size = Length;
+				int iend = size;
+				if (start < 0)
+					start = size + start;
+
+				if (start < 0 || start >= size || start >= iend)
+					return Empty;
+				if (iend < 0 || iend > size)
+					return Empty;
+				return GetRange (start, iend);
+			}
+		}
+
 		/// <summary>
 		/// Returns the substring starting at the given position.
 		/// </summary>
@@ -1476,7 +1530,7 @@ ustring [] GenSplit (ustring sep, int sepSave, int n = -1)
 				offset = m + sepLen;
 				i++;
 			}
-			result [i] = this [offset, 0];
+			result [i] = this [offset, null];
 			return result;
 		}
 
@@ -1857,7 +1911,7 @@ public ustring TrimStart (RunePredicate predicate)
 			var i = FlexIndexOf (predicate, false);
 			if (i == -1)
 				return this;
-			return this [i, 0];
+			return this [i, null];
 		}
 
 		RunePredicate MakeCutSet (ustring cutset)
@@ -1913,7 +1967,7 @@ public ustring TrimEnd (RunePredicate predicate)
 		{
 			var i = FlexLastIndexOf (predicate, false);
 			if (i >= 0 && this [i] >= Utf8.RuneSelf) {
-				(var rune, var wid) = Utf8.DecodeRune (this [i, 0]);
+				(var rune, var wid) = Utf8.DecodeRune (this [i, null]);
 				i += wid;
 			} else
 				i++;

NStackTests/Utf8Test.cs

@@ -203,7 +203,7 @@ public void TestSequence (ustring s)
 				j++;
 				(var r1, var size1) = Utf8.DecodeRune (Subset (s.ToByteArray (), i, -1));
 				Assert.AreEqual (rune, r1, "DecodeRune 0x{0:x} = want 0x{1:x} with {2}", r1, rune, s);
-				(var r2, var size2) = Utf8.DecodeRune (s [i, 0]);
+				(var r2, var size2) = Utf8.DecodeRune (s [i, null]);
 				Assert.AreEqual (size1, size2);
 				si += size1;
 			}

NStackTests/ustringTest.cs

@@ -115,10 +115,10 @@ public void Equals ()
 			Assert.IsTrue (ast [1, 5] == bp [1, 5]);
 			Assert.IsTrue (ap [1, 5] == bst [1, 5]);
 			Assert.IsTrue (ast [1, 5] == bp [1, 5]);
-			Assert.IsTrue (ast [8, 0] != cp [8, 0]);
+			Assert.IsTrue (ast [8, null] != cp [8, null]);
 			Assert.IsTrue (cp [1, 5] == cpalias [1, 5]);
 			Assert.IsTrue (cp [1, 5] == cst [1, 5]);
-			Assert.IsTrue (cp [8, 0] != bst [8, 0]);
+			Assert.IsTrue (cp [8, null] != bst [8, null]);
 
 		}
 
@@ -324,15 +324,18 @@ void SliceTests (ustring a)
 		{
 			Assert.AreEqual ("1234", a [0, 4].ToString ());
 			Assert.AreEqual ("90", a [8, 10].ToString ());
-			Assert.AreEqual ("90", a [8, 0].ToString ());
-			Assert.AreEqual ("90", a [-2, 0].ToString ());
+			Assert.AreEqual ("90", a [8, null].ToString ());
+			Assert.AreEqual ("90", a [-2, null].ToString ());
 			Assert.AreEqual ("9", a [8, 9].ToString ());
 			Assert.AreEqual ("789", a [-4, -1].ToString ());
-			Assert.AreEqual ("7890", a [-4, 0].ToString ());
-			Assert.AreEqual ("7890", a [-4, 0].ToString ());
+			Assert.AreEqual ("7890", a [-4, null].ToString ());
+			Assert.AreEqual ("7890", a [-4, null].ToString ());
 			Assert.AreEqual ("234567", a [-9, -3].ToString ());
 			Assert.AreEqual ("", a [100, 200].ToString ());
+			Assert.AreEqual ("", a [-100, null].ToString ());
+
 			Assert.AreEqual ("", a [-100, 0].ToString ());
+			Assert.AreEqual ("", a [0, 0].ToString ());
 		}
 
 		[Test]
@@ -396,6 +399,7 @@ public void Split ()
 		{
 			var gecos = ustring.Make ("miguel:*:100:200:Miguel de Icaza:/home/miguel:/bin/bash");
 			var fields = gecos.Split (":");
+
 			Assert.AreEqual (7, fields.Length);
 			Assert.IsTrue (ustring.Make ("miguel") == fields [0]);
 			Assert.IsTrue (ustring.Make ("*") == fields [1]);