Implemented StartingWith method

Author: Lexey

Experimental/src/Collections/Suffix.cs

@@ -8,22 +8,25 @@ public struct Suffix
 	{
 		/// <summary>Buffer of all added strings</summary>
 		private readonly string _buffer;
-		/// <summary>Offset to the beginning of the suffix in the buffer</summary>
-		private readonly int _offset;
+		/// <summary>Offset to the beginning of the source string in the buffer</summary>
+		private readonly int _sourceOffset;
 
 		/// <summary>Constructs a new suffix</summary>
 		/// <param name="buffer">Buffer with all added strings</param>
 		/// <param name="sourceIndex">Source string index</param>
-		/// <param name="offset">Offset of the suffix in the buffer</param>
+		/// <param name="sourceOffset">Offset of the source string inside the buffer</param>
+		/// <param name="offset">Offset of the suffix from the sourceOffset</param>
 		/// <param name="length">Length of the suffix</param>
-		internal Suffix([NotNull] string buffer, int sourceIndex, int offset, int length)
+		internal Suffix([NotNull] string buffer, int sourceIndex, int sourceOffset, int offset, int length)
 		{
 			DebugCode.NotNull(buffer, nameof(buffer));
 			DebugCode.ValidIndex(sourceIndex, nameof(sourceIndex));
-			DebugCode.ValidIndexAndCount(offset, nameof(offset), length, nameof(length), buffer.Length);
+			DebugCode.ValidIndex(sourceOffset, nameof(sourceOffset), buffer.Length);
+			DebugCode.ValidIndexAndCount(sourceOffset + offset, nameof(offset), length, nameof(length), buffer.Length);
 			_buffer = buffer;
 			SourceIndex = sourceIndex;
-			_offset = offset;
+			_sourceOffset = sourceOffset;
+			Offset = offset;
 			Length = length;
 		}
 
@@ -32,10 +35,12 @@ internal Suffix([NotNull] string buffer, int sourceIndex, int offset, int length
 		/// <remarks>0 - for the first added string, 1 - for the second, etc</remarks>
 		/// </summary>
 		public int SourceIndex { get; }
+		/// <summary>The offset of the suffix from the beginning of the source string</summary>
+		public int Offset { get; }
 		/// <summary>The length of the suffix</summary>
 		public int Length { get; }
 		/// <summary>The suffix value</summary>
-		public string Value => _buffer.Substring(_offset, Length);
+		public string Value => _buffer.Substring(_sourceOffset + Offset, Length);
 
 		/// <summary>String conversion operator</summary>
 		/// <param name="suffix">The suffix to convert</param>

Experimental/src/Collections/SuffixTree.cs

@@ -21,13 +21,11 @@ public class SuffixTree : SuffixTreeBase
 
 		/// <summary>Links between nodes</summary>
 		private Lazy<List<int>> _nodeLinks;
-		/// <summary>Comparer for nodes against a char</summary>
-		private Func<int, char, int> _childComparer;
 		// state: (activeNode_, activeChild_, activeLength_), pending_
 		/// <summary>Index of the branch node</summary>
 		private int _branchNodeIndex;
 		/// <summary>Index of the active edge (child node) of the branch node</summary>
-		private int _activeEdgeIndex ;
+		private int _activeEdgeIndex;
 		/// <summary>The length of the current part of the active child</summary>
 		private int activeLength_;
 		/// <summary>Offset of the first suffix to insert</summary>
@@ -61,7 +59,6 @@ private void ResetLinks() => _nodeLinks =
 		protected override void BuildFor(int begin, int end)
 		{
 			Code.AssertState(begin < end, "Invalid parameters passed");
-			_childComparer = GetComparer();
 			_branchNodeIndex = RootNodeIndex;
 			_activeEdgeIndex = InvalidNodeIndex;
 			activeLength_ = 0;
@@ -93,7 +90,6 @@ protected override void BuildFor(int begin, int end)
 				}
 				UpdateActiveEdgeAndCurentPosition();
 			}
-			_childComparer = null;
 		}
 
 		/// <summary>Finds the next branching point</summary>
@@ -113,10 +109,10 @@ private void FindBranchingPoint()
 				childNodeIndex = InvalidNodeIndex;
 				activeEdge = default(Node);
 			}
-			for(;;)
+			for (;;)
 			{
 				if (_activeEdgeIndex == InvalidNodeIndex)
-				{					
+				{
 					DebugCode.AssertState(activeLength_ == 0, "Invalid active state");
 					if (_currentOffset == _end)
 					{
@@ -128,7 +124,7 @@ private void FindBranchingPoint()
 						return;
 					}
 					var c = InternalData[_currentOffset];
-					var childIndex = children.LowerBound(c, _childComparer);
+					var childIndex = children.LowerBound(c, EdgeComparer);
 					if (childIndex == children.Count)
 					{
 						// a new branch
@@ -219,7 +215,7 @@ private void UpdateActiveEdgeAndCurentPosition()
 				DebugCode.AssertState(!branchNode.IsLeaf, "Invalid active state");
 				var index = _currentOffset - activeLength_;
 				var children = branchNode.Children;
-				var childIndex = children.LowerBound(InternalData[index], _childComparer);
+				var childIndex = children.LowerBound(InternalData[index], EdgeComparer);
 				DebugCode.AssertState(childIndex != children.Count, "Invalid active state");
 				var edgeIndex = children[childIndex];
 				var edgeNode = GetNode(edgeIndex);
@@ -295,7 +291,7 @@ private void InsertSuffix()
 			{
 				childNodeIndex = _currentOffset == _end
 					? 0 // empty nodes always at the beginning
-					: children.LowerBound(InternalData[_currentOffset], _childComparer);
+					: children.LowerBound(InternalData[_currentOffset], EdgeComparer);
 			}
 			// now we have a non-empty children and an insertion index
 			// just do an insert
@@ -328,7 +324,7 @@ protected override void PrintNodeText(StringBuilder sb, int nodeIndex)
 		{
 			var n = GetNode(nodeIndex);
 			var nodeLink = _nodeLinks.IsValueCreated ? _nodeLinks.Value[nodeIndex] : InvalidNodeIndex;
-			var linkText = nodeLink != InvalidNodeIndex ? $" -> {nodeLink}" : string.Empty; 
+			var linkText = nodeLink != InvalidNodeIndex ? $" -> {nodeLink}" : string.Empty;
 			sb.AppendLine($"({nodeIndex}{linkText}, [{n.Begin}-{n.End}), {InternalData.Substring(n.Begin, n.End - n.Begin)})");
 		}
 	}