string _trim(int startIndex, int endIndex, bool trimStart, bool trimEnd)
{
if (startIndex == endIndex)
{
return(string.Empty);
}
if (trimStart)
{
while (UnderlyingString[startIndex].IsWhiteSpace())
{
++startIndex;
if (startIndex >= endIndex)
{
return(string.Empty);
}
}
}
if (trimEnd)
{
while (UnderlyingString[endIndex - 1].IsWhiteSpace())
{
--endIndex;
if (endIndex <= startIndex)
{
return(string.Empty);
}
}
}
return(UnderlyingString.Substring(startIndex, endIndex - startIndex));
}
private StoragePath?GetParent()
{
if (IsRootPathOnly())
{
return(null);
}
// Find the index of the first separator from behind and then (to fulfill spec) continue
// walking down until the last consecutive char has been passed.
var rootLength = GetRootLength();
var endIndex = Length;
while (endIndex > rootLength && !IsDirectorySeparator(UnderlyingString[endIndex - 1]))
{
endIndex--;
}
while (endIndex > rootLength && IsDirectorySeparator(UnderlyingString[endIndex - 1]))
{
endIndex--;
}
// If there has been no directory separator there is no parent (can happen with relative paths).
if (endIndex <= 0)
{
return(null);
}
return(FileSystem.GetPath(UnderlyingString.Substring(0, endIndex)));
}
/// <summary>
/// Reads a string consisting of ASCII letters and digits, plus characters specified in <paramref name="additionalChars"/> at the beginning of the reading scope.
/// </summary>
/// <param name="additionalChars">Specifies additional characters to read.</param>
/// <returns>A string at the beginning of the current reading scope, consisting of ASCII letters and digits plus <paramref name="additionalChars"/>.</returns>
public string ReadASCIILettersAndDigits(params char[] additionalChars)
{
var pos = CurrentPosition;
while (!EOF && (First.IsASCIILetterOrDigit() || First.In(additionalChars)))
{
Advance();
}
return(UnderlyingString.Substring(pos, CurrentPosition - pos));
}
/// <summary>
/// Advances this reader to the end of the search scope and returns a substring starting from the current position to the end of the search scope. NOTE that after executing this method, this reader is marked <see cref="EOF"/> and is no longer readable.
/// </summary>
/// <returns>A substring of the underlying string of this reader, starting from the current position to the end of the reading scope, if the current reader is not marked EOF; otherwise, <see cref="String.Empty"/>.</returns>
public string ReadToEnd()
{
if (CurrentPosition == EndPosition)
{
return(string.Empty);
}
else
{
var output = UnderlyingString.Substring(CurrentPosition, EndPosition - CurrentPosition);
CurrentPosition = EndPosition;
return(output);
}
}
/// <summary>
/// For internal use only. The same as <see cref="SubstringBeforeCurrentPosition"/> except that the white spaces at the end of returned string are trimmed.
/// </summary>
/// <param name="prevPos">Provides a position prior to the reader's <see cref="CurrentPosition"/>.</param>
/// <returns>A substring starting from the specified <paramref name="prevPos" /> to the character previous to the <see cref="CurrentPosition" />. Note the first character of the current reading scope is not contained in the returned substring. <c>null</c> is returned if <paramref name="prevPos" /> equals <see cref="CurrentPosition" />.</returns>
internal string InnerSubstringBeforeCurrentPositionWithTrimEnd(int prevPos)
{
if (prevPos == CurrentPosition)
{
return(null);
}
var pos = CurrentPosition - 1;
while (UnderlyingString[pos].IsWhiteSpace())
{
--pos;
if (pos < prevPos)
{
return(null);
}
}
return(UnderlyingString.Substring(prevPos, pos + 1 - prevPos));
}
/// <summary>
/// Reads a variable name from this reader. The valid first character of the variable name is defined by the <paramref name="isValidVariableFirstChr"/>, and a valid variable name character (except the first character) is defined by <paramref name="isValidVariableChr"/>.
/// </summary>
/// <returns>A variable name read from this reader.</returns>
public string ReadVariableName(Func <char, bool> isValidVariableFirstChr, Func <char, bool> isValidVariableChr)
{
var pos = CurrentPosition; //! DO NOT use MarkPosition; it is for external use.
if (isValidVariableFirstChr(First))
{
Advance();
}
else
{
return(null);
}
while (!EOF && isValidVariableChr(First))
{
Advance();
}
return(UnderlyingString.Substring(pos, CurrentPosition - pos));
}
/// <summary>
/// Reads a WAS reference name from this reader. The valid first character of the variable name can either be a ASCII letter, or '_'; and a valid variable name character (except the first character) can either be a ASCII letter or ASCII digit or '_' or '-'.
/// </summary>
/// <returns>A variable name read from this reader.</returns>
public string ReadWASReferenceName()
{
var pos = CurrentPosition; //! DO NOT use MarkPosition; it is for external use.
if (First.IsASCIILetter() || First == '_')
{
Advance();
}
else
{
return(null);
}
while (!EOF && First.IsASCIILetterOrDigit() || First == '_' || First == '-')
{
Advance();
}
return(UnderlyingString.Substring(pos, CurrentPosition - pos));
}
private StoragePath TrimEndingDirectorySeparatorImpl()
{
if (!EndsWithDirectorySeparator)
{
return(this);
}
if (Length == 1)
{
throw new InvalidOperationException(ExceptionStrings.StoragePath.TrimmingResultsInEmptyPath());
}
var trimmedPath = UnderlyingString.Substring(0, UnderlyingString.Length - 1);
try
{
return(FileSystem.GetPath(trimmedPath));
}
catch (Exception ex)
{
throw new InvalidOperationException(ExceptionStrings.StoragePath.TrimmingResultsInInvalidPath(), ex);
}
}
private string GetName()
{
if (IsRootPathOnly())
{
return(string.Empty);
}
// Specification requires us to ignore exactly one trailing directory separator character.
// The name starts at the position of the last directory separator character except for
// that trailing one.
var startIndex = 0;
var endIndex = EndsWithDirectorySeparator ? Length - 2 : Length - 1;
for (var i = endIndex; i >= 0; i--)
{
if (IsDirectorySeparator(UnderlyingString[i]))
{
startIndex = i + 1;
break;
}
}
return(UnderlyingString.Substring(startIndex, endIndex - startIndex + 1));
}
public override string ToString()
{
return(UnderlyingString?.Substring(Index, Length) ?? String.Empty);
}
public override string ToString()
{
return(UnderlyingString.Substring(Index, Length));
}
/// <summary>
/// For internal use only. The internal version of <see cref="SubstringBeforeCurrentPosition"/> without argument check.
/// </summary>
/// <param name="prevPos">Provides a position prior to the reader's <see cref="CurrentPosition"/>.</param>
/// <returns>A substring starting from the specified <paramref name="prevPos" /> to the character previous to the <see cref="CurrentPosition" />. Note the first character of the current reading scope is not contained in the returned substring. <c>null</c> is returned if <paramref name="prevPos" /> equals <see cref="CurrentPosition" />.</returns>
internal string InnerSubstringBeforeCurrentPosition(int prevPos)
{
return(CurrentPosition == prevPos ? null : UnderlyingString.Substring(prevPos, CurrentPosition - prevPos));
}
/// <summary>
/// Returns a substring of the underlying string instance of this reader, starting from the current position to the limit of this reader.
/// </summary>
/// <returns>
/// A <see cref="System.String" /> that is a substring of the underlying string instance of this reader.
/// </returns>
public override string ToString()
{
return(UnderlyingString.Substring(CurrentPosition, EndPosition - CurrentPosition));
}
