515 lines
20 KiB
C#
515 lines
20 KiB
C#
using QFSW.QC.Containers;
|
|
using QFSW.QC.Pooling;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace QFSW.QC
|
|
{
|
|
public static class TextProcessing
|
|
{
|
|
public static readonly char[] DefaultLeftScopers = { '<', '[', '(', '{', '"' };
|
|
public static readonly char[] DefaultRightScopers = { '>', ']', ')', '}', '"' };
|
|
|
|
private static readonly ConcurrentStringBuilderPool _stringBuilderPool = new ConcurrentStringBuilderPool();
|
|
|
|
/// <summary>
|
|
/// Options to provide the ReduceScoped functions with
|
|
/// </summary>
|
|
public struct ReduceScopeOptions
|
|
{
|
|
/// <summary>
|
|
/// The maximum number of times the scope can be reduced by.
|
|
/// Setting to -1 will allow for an unlimited number.
|
|
/// </summary>
|
|
public int MaxReductions;
|
|
|
|
/// <summary>
|
|
/// If incomplete scopes should also be reduced
|
|
/// For example, the following text -> "((foo0 foo1)" when using () for scoping
|
|
/// - false: "(foo0 foo1"
|
|
/// - true: "foo0 foo1"
|
|
/// </summary>
|
|
public bool ReduceIncompleteScope;
|
|
|
|
/// <summary>
|
|
/// The default set of options for the ReduceScope functions
|
|
/// </summary>
|
|
public static readonly ReduceScopeOptions Default = new ReduceScopeOptions
|
|
{
|
|
MaxReductions = -1,
|
|
ReduceIncompleteScope = false
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Options to provide the SplitScoped functions with
|
|
/// </summary>
|
|
public struct ScopedSplitOptions
|
|
{
|
|
/// <summary>
|
|
/// The maximum number of items to split the string into.
|
|
/// Setting to -1 will allow for an unlimited number.
|
|
/// </summary>
|
|
public int MaxCount;
|
|
|
|
/// <summary>
|
|
/// If the scope should automatically be reduced when performing scoped splitting.
|
|
/// </summary>
|
|
public bool AutoReduceScope;
|
|
|
|
/// <summary>
|
|
/// The default set of options for the SplitScoped functions
|
|
/// </summary>
|
|
public static readonly ScopedSplitOptions Default = new ScopedSplitOptions
|
|
{
|
|
MaxCount = -1,
|
|
AutoReduceScope = false,
|
|
};
|
|
}
|
|
|
|
#region GetMaxScopeDepthAtEnd
|
|
|
|
public static int GetMaxScopeDepthAtEnd(this string input)
|
|
{
|
|
return input.GetMaxScopeDepthAtEnd(DefaultLeftScopers, DefaultRightScopers);
|
|
}
|
|
|
|
public static int GetMaxScopeDepthAtEnd(this string input, char leftScoper, char rightScoper)
|
|
{
|
|
return input.GetMaxScopeDepthAtEnd(leftScoper.AsArraySingle(), rightScoper.AsArraySingle());
|
|
}
|
|
|
|
public static int GetMaxScopeDepthAtEnd<T>(this string input, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
return input.GetMaxScopeDepthAt(input.Length - 1, leftScopers, rightScopers);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetMaxScopeDepthAt
|
|
|
|
public static int GetMaxScopeDepthAt(this string input, int cursor)
|
|
{
|
|
return input.GetMaxScopeDepthAt(cursor, DefaultLeftScopers, DefaultRightScopers);
|
|
}
|
|
|
|
public static int GetMaxScopeDepthAt(this string input, int cursor, char leftScoper, char rightScoper)
|
|
{
|
|
return input.GetMaxScopeDepthAt(cursor, leftScoper.AsArraySingle(), rightScoper.AsArraySingle());
|
|
}
|
|
|
|
public static int GetMaxScopeDepthAt<T>(this string input, int cursor, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
int[] scopes = new int[leftScopers.Count];
|
|
for (int i = 0; i <= cursor; i++)
|
|
{
|
|
if (i == 0 || input[i - 1] != '\\')
|
|
{
|
|
for (int j = 0; j < leftScopers.Count; j++)
|
|
{
|
|
char leftScoper = leftScopers[j];
|
|
char rightScoper = rightScopers[j];
|
|
|
|
if (input[i] == leftScoper && leftScoper == rightScoper) { scopes[j] = 1 - scopes[j]; }
|
|
else if (input[i] == leftScoper) { scopes[j]++; }
|
|
else if (input[i] == rightScoper) { scopes[j]--; }
|
|
}
|
|
}
|
|
}
|
|
|
|
return scopes.Max();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ReduceScope
|
|
|
|
public static string ReduceScope(this string input)
|
|
{
|
|
return input.ReduceScope(DefaultLeftScopers, DefaultRightScopers, ReduceScopeOptions.Default);
|
|
}
|
|
|
|
public static string ReduceScope(this string input, ReduceScopeOptions options)
|
|
{
|
|
return input.ReduceScope(DefaultLeftScopers, DefaultRightScopers, options);
|
|
}
|
|
|
|
public static string ReduceScope(this string input, char leftScoper, char rightScoper)
|
|
{
|
|
return input.ReduceScope(leftScoper.AsArraySingle(), rightScoper.AsArraySingle(), ReduceScopeOptions.Default);
|
|
}
|
|
|
|
public static string ReduceScope(this string input, char leftScoper, char rightScoper, ReduceScopeOptions options)
|
|
{
|
|
return input.ReduceScope(leftScoper.AsArraySingle(), rightScoper.AsArraySingle(), options);
|
|
}
|
|
|
|
public static string ReduceScope<T>(this string input, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
return ReduceScope(input, leftScopers, rightScopers, ReduceScopeOptions.Default);
|
|
}
|
|
|
|
public static string ReduceScope<T>(this string input, T leftScopers, T rightScopers, ReduceScopeOptions options)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
if (leftScopers.Count != rightScopers.Count)
|
|
{
|
|
throw new ArgumentException("There must be an equal number of corresponding left and right scopers");
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(input))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
if (options.MaxReductions == 0)
|
|
{
|
|
return input;
|
|
}
|
|
|
|
// Use cursors to point into the current string instead of repeated
|
|
// substrings for improved performance
|
|
int leftCursor = 0;
|
|
int rightCursor = input.Length - 1;
|
|
|
|
// Determines if a cursor is pointing to an escaped character
|
|
bool IsEscaped(int cursor)
|
|
{
|
|
return cursor > 0 && input[cursor - 1] == '\\';
|
|
}
|
|
|
|
int totalScopeReductions = 0;
|
|
bool workRemaining = true;
|
|
|
|
// Keep descoping the string until we either run out of work to do, or we hit the maximum number of reductions
|
|
while (workRemaining && (totalScopeReductions < options.MaxReductions || options.MaxReductions < 0))
|
|
{
|
|
// If the left cursor ever surpasses the right, we have descoped to an empty string
|
|
if (leftCursor > rightCursor)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
// Update cursors to skip over any whitespace to emulate Trim
|
|
workRemaining = false;
|
|
while (char.IsWhiteSpace(input[leftCursor])) { leftCursor++; }
|
|
while (char.IsWhiteSpace(input[rightCursor])) { rightCursor--; }
|
|
|
|
// If the right cursor is escaped, then finish here
|
|
if (IsEscaped(rightCursor))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Check each pair of scopers
|
|
for (int i = 0; i < leftScopers.Count; i++)
|
|
{
|
|
char leftScoper = leftScopers[i];
|
|
char rightScoper = rightScopers[i];
|
|
bool sameScoper = leftScoper == rightScoper;
|
|
|
|
// Determines if we've hit a valid scoper pair
|
|
bool validScoperPair = input[leftCursor] == leftScoper && input[rightCursor] == rightScoper;
|
|
bool incompleteReduction = false;
|
|
|
|
if (!validScoperPair && options.ReduceIncompleteScope)
|
|
{
|
|
// Only the left cursor needs to match for incomplete scope reduction
|
|
validScoperPair = input[leftCursor] == leftScoper;
|
|
incompleteReduction = validScoperPair;
|
|
}
|
|
|
|
if (validScoperPair)
|
|
{
|
|
// Search between the two cursors to make sure scope never drops down to 0 between them
|
|
// as this would be two separate scopes being incorrectly descoped
|
|
bool scopeBreaks = false;
|
|
int currentScope = 1;
|
|
int leftSearch = leftCursor + 1;
|
|
int rightSearch = rightCursor - 1;
|
|
|
|
// Only perform search if there is a valid search range
|
|
if (leftSearch <= rightSearch)
|
|
{
|
|
// Logic for same scoper is a bit different since we can't really define a scope depth
|
|
// If it's impossible to remove inner scope characters by stripping the outer pair
|
|
// of scopers then this is a broken scope, otherwise its fine - update the search range to allow for this
|
|
// fine : ""foo""
|
|
// not fine : "foo1""foo2"
|
|
if (sameScoper)
|
|
{
|
|
// Determines if the cursor location can skip searching for same scoper case
|
|
bool SkipSearch(int cursor)
|
|
{
|
|
if (IsEscaped(cursor))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return input[cursor] == leftScoper || char.IsWhiteSpace(input[cursor]);
|
|
}
|
|
|
|
while (SkipSearch(leftSearch)) { leftSearch++; }
|
|
while (SkipSearch(rightSearch)) { rightSearch--; }
|
|
}
|
|
|
|
// Perform the search
|
|
for (int j = leftSearch; j <= rightSearch; j++)
|
|
{
|
|
// Ignore escaped characters
|
|
if (IsEscaped(j))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (sameScoper)
|
|
{
|
|
// If we find any scopers inside the refined scope range then we can't descope
|
|
if (input[j] == leftScoper)
|
|
{
|
|
scopeBreaks = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// For normal scopers, just check that scope never hits 0
|
|
// Update the current scope level
|
|
if (input[j] == leftScoper) { currentScope++; }
|
|
else if (input[j] == rightScoper) { currentScope--; }
|
|
|
|
// Scope broken if it hits 0
|
|
if (currentScope == 0)
|
|
{
|
|
scopeBreaks = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the scope never breaks, then we can successfully descope
|
|
if (!scopeBreaks)
|
|
{
|
|
// Update the cursors and break out of for loop
|
|
// Don't move the right cursor for incomplete reduction
|
|
if (!incompleteReduction)
|
|
{
|
|
rightCursor--;
|
|
}
|
|
|
|
leftCursor++;
|
|
totalScopeReductions++;
|
|
workRemaining = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Perform substring on cursors to get final descoped output if required
|
|
return totalScopeReductions > 0
|
|
? input.Substring(leftCursor, rightCursor - leftCursor + 1)
|
|
: input;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SplitScoped
|
|
|
|
public static string[] SplitScoped(this string input, char splitChar)
|
|
{
|
|
return input.SplitScoped(splitChar, ScopedSplitOptions.Default);
|
|
}
|
|
|
|
public static string[] SplitScoped(this string input, char splitChar, ScopedSplitOptions options)
|
|
{
|
|
return input.SplitScoped(splitChar, DefaultLeftScopers, DefaultRightScopers, options);
|
|
}
|
|
|
|
public static string[] SplitScoped(this string input, char splitChar, char leftScoper, char rightScoper)
|
|
{
|
|
return input.SplitScoped(splitChar, leftScoper.AsArraySingle(), rightScoper.AsArraySingle(), ScopedSplitOptions.Default);
|
|
}
|
|
|
|
public static string[] SplitScoped(this string input, char splitChar, char leftScoper, char rightScoper, ScopedSplitOptions options)
|
|
{
|
|
return input.SplitScoped(splitChar, leftScoper.AsArraySingle(), rightScoper.AsArraySingle(), options);
|
|
}
|
|
|
|
public static string[] SplitScoped<T>(this string input, char splitChar, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
return SplitScoped(input, splitChar, leftScopers, rightScopers, ScopedSplitOptions.Default);
|
|
}
|
|
|
|
public static string[] SplitScoped<T>(this string input, char splitChar, T leftScopers, T rightScopers, ScopedSplitOptions options)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
if (options.AutoReduceScope)
|
|
{
|
|
input = input.ReduceScope(leftScopers, rightScopers);
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(input))
|
|
{
|
|
return Array.Empty<string>();
|
|
}
|
|
|
|
IEnumerable<int> rawSplitIndices = GetScopedSplitPoints(input, splitChar, leftScopers, rightScopers);
|
|
int[] splitIndices =
|
|
options.MaxCount > 0
|
|
? rawSplitIndices.Take(options.MaxCount - 1).ToArray()
|
|
: rawSplitIndices.ToArray();
|
|
|
|
// Return single array when no splits occurred
|
|
if (splitIndices.Length == 0)
|
|
{
|
|
return new[] { input };
|
|
}
|
|
|
|
string[] splitString = new string[splitIndices.Length + 1];
|
|
int lastSplitIndex = 0;
|
|
for (int i = 0; i < splitIndices.Length; i++)
|
|
{
|
|
splitString[i] = input.Substring(lastSplitIndex, splitIndices[i] - lastSplitIndex).Trim();
|
|
lastSplitIndex = splitIndices[i] + 1;
|
|
}
|
|
|
|
splitString[splitIndices.Length] = input.Substring(lastSplitIndex).Trim();
|
|
return splitString;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetScopedSplitPoints
|
|
|
|
public static IEnumerable<int> GetScopedSplitPoints<T>(string input, char splitChar, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
return GetScopedSplitPoints(input, splitChar, leftScopers, rightScopers, ScopedSplitOptions.Default);
|
|
}
|
|
|
|
public static IEnumerable<int> GetScopedSplitPoints<T>(
|
|
string input, char splitChar, T leftScopers, T rightScopers, ScopedSplitOptions options)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
if (leftScopers.Count != rightScopers.Count)
|
|
{
|
|
throw new ArgumentException("There must be an equal number of corresponding left and right scopers");
|
|
}
|
|
|
|
int[] scopes = new int[leftScopers.Count];
|
|
for (int i = 0; i < input.Length; i++)
|
|
{
|
|
if (i == 0 || input[i - 1] != '\\')
|
|
{
|
|
for (int j = 0; j < leftScopers.Count; j++)
|
|
{
|
|
char leftScoper = leftScopers[j];
|
|
char rightScoper = rightScopers[j];
|
|
|
|
if (input[i] == leftScoper && leftScoper == rightScoper) { scopes[j] = 1 - scopes[j]; }
|
|
else if (input[i] == leftScoper) { scopes[j]++; }
|
|
else if (input[i] == rightScoper) { scopes[j]--; }
|
|
}
|
|
}
|
|
|
|
if (input[i] == splitChar && scopes.All(x => x == 0))
|
|
{
|
|
yield return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static bool CanSplitScoped(this string input, char splitChar)
|
|
{
|
|
return input.CanSplitScoped(splitChar, DefaultLeftScopers, DefaultRightScopers);
|
|
}
|
|
|
|
public static bool CanSplitScoped(this string input, char splitChar, char leftScoper, char rightScoper)
|
|
{
|
|
return input.CanSplitScoped(splitChar, leftScoper.AsArraySingle(), rightScoper.AsArraySingle());
|
|
}
|
|
|
|
public static bool CanSplitScoped<T>(this string input, char splitChar, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
return GetScopedSplitPoints(input, splitChar, leftScopers, rightScopers).Any();
|
|
}
|
|
|
|
public static string SplitFirst(this string input, char splitChar)
|
|
{
|
|
return input.SplitScopedFirst(splitChar, Array.Empty<char>(), Array.Empty<char>());
|
|
}
|
|
|
|
public static string SplitScopedFirst(this string input, char splitChar)
|
|
{
|
|
return input.SplitScopedFirst(splitChar, DefaultLeftScopers, DefaultRightScopers);
|
|
}
|
|
|
|
public static string SplitScopedFirst(this string input, char splitChar, char leftScoper, char rightScoper)
|
|
{
|
|
return input.SplitScopedFirst(splitChar, leftScoper.AsArraySingle(), rightScoper.AsArraySingle());
|
|
}
|
|
|
|
public static string SplitScopedFirst<T>(this string input, char splitChar, T leftScopers, T rightScopers)
|
|
where T : IReadOnlyList<char>
|
|
{
|
|
IEnumerable<int> splitPoints = GetScopedSplitPoints(input, splitChar, leftScopers, rightScopers);
|
|
foreach (int splitPoint in splitPoints)
|
|
{
|
|
return input.Substring(0, splitPoint).Trim();
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
public static string UnescapeText(this string input, char escapeChar) { return input.UnescapeText(escapeChar.AsArraySingle()); }
|
|
public static string UnescapeText<T>(this string input, T escapeChars)
|
|
where T : IReadOnlyCollection<char>
|
|
{
|
|
foreach (char escapeChar in escapeChars)
|
|
{
|
|
input = input.Replace($"\\{escapeChar}", escapeChar.ToString());
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
public static string ReverseItems(this string input, char splitChar)
|
|
{
|
|
int lastSplit = input.Length;
|
|
StringBuilder buffer = _stringBuilderPool.GetStringBuilder(input.Length);
|
|
|
|
for (int i = input.Length - 1; i >= 0; i--)
|
|
{
|
|
if (input[i] == splitChar)
|
|
{
|
|
int substringIndex = i + 1;
|
|
if (substringIndex < input.Length)
|
|
{
|
|
buffer.Append(input, substringIndex, lastSplit - substringIndex);
|
|
}
|
|
|
|
buffer.Append(splitChar);
|
|
lastSplit = i;
|
|
}
|
|
else if (i == 0)
|
|
{
|
|
buffer.Append(input, 0, lastSplit);
|
|
}
|
|
}
|
|
|
|
return _stringBuilderPool.ReleaseAndToString(buffer);
|
|
}
|
|
}
|
|
}
|