| public static TokenizeToStringArray ( string value, string delimiters, bool trimTokens = true, bool ignoreEmptyTokens = true ) : string[] | ||
| value | string | |
| delimiters | string | |
| trimTokens | bool | |
| ignoreEmptyTokens | bool | |
| Résultat | string[] | |
public string ExtractPathWithinPattern(string pattern, string path)
{
string[] patternParts = StringUtils.TokenizeToStringArray(pattern, PathSeparator);
string[] pathParts = StringUtils.TokenizeToStringArray(path, PathSeparator);
var builder = new StringBuilder();
var puts = 0;
for (var i = 0; i < patternParts.Length; ++i)
{
var part = patternParts[i];
if ((part.Contains("*") || part.Contains("?")) && pathParts.Length >= (i + 1))
{
if (puts > 0 || (i == 0 && !pattern.StartsWith(PathSeparator)))
{
builder.Append(PathSeparator);
}
builder.Append(pathParts[i]);
++puts;
}
}
for (var i = patternParts.Length; i < pathParts.Length; ++i)
{
if (puts > 0 || i > 0)
{
builder.Append(PathSeparator);
}
builder.Append(pathParts[i]);
}
return(builder.ToString());
}
protected bool DoMatch(string pattern, string path, bool fullMatch)
{
if (path.StartsWith(PathSeparator) != pattern.StartsWith(PathSeparator))
{
return(false);
}
var patternParts = StringUtils.TokenizeToStringArray(pattern, PathSeparator);
var pathParts = StringUtils.TokenizeToStringArray(path, PathSeparator);
var patternStartIndex = 0;
var patternEndIndex = patternParts.Length - 1;
var pathStartIndex = 0;
var pathEndIndex = pathParts.Length - 1;
// Match all elements up to the first **
while (patternStartIndex <= patternEndIndex && pathStartIndex <= pathEndIndex)
{
var patternPart = patternParts[patternStartIndex];
if (patternPart == "**")
{
break;
}
if (!MatchStrings(patternPart, pathParts[pathStartIndex]))
{
return(false);
}
pathStartIndex++;
patternStartIndex++;
}
if (pathStartIndex > pathEndIndex)
{
// Path is exhausted, only match if rest of pattern is * or **'s
if (patternStartIndex > patternEndIndex)
{
return(pattern.EndsWith(PathSeparator) == path.EndsWith(PathSeparator));
}
if (!fullMatch)
{
return(true);
}
if (patternStartIndex == patternEndIndex &&
patternParts[patternStartIndex] == "*" &&
path.EndsWith(PathSeparator))
{
return(true);
}
for (int i = patternStartIndex; i <= patternEndIndex; i++)
{
if (patternParts[i] != "**")
{
return(false);
}
}
return(true);
}
else if (patternStartIndex > patternEndIndex)
{
// String not exhausted, but pattern is. Failure.
return(false);
}
else if (!fullMatch && patternParts[patternStartIndex] == "**")
{
// Path start definitely matches due to "**" part in pattern.
return(true);
}
// up to last '**'
while (patternStartIndex <= patternEndIndex && pathStartIndex <= pathEndIndex)
{
var patternPart = patternParts[patternEndIndex];
if ("**" == patternPart)
{
break;
}
if (!MatchStrings(patternPart, pathParts[pathEndIndex]))
{
return(false);
}
pathEndIndex--;
patternEndIndex--;
}
if (pathStartIndex > pathEndIndex)
{
// String is exhausted
for (var i = patternStartIndex; i <= patternEndIndex; i++)
{
if (patternParts[i] != "**")
{
return(false);
}
}
return(true);
}
while (patternStartIndex != patternEndIndex && pathStartIndex <= pathEndIndex)
{
int index = -1;
for (var i = patternStartIndex + 1; i <= patternEndIndex; i++)
{
if (patternParts[i] == "**")
{
index = i;
break;
}
}
if (index == patternStartIndex + 1)
{
// '**/**' situation, so skip one
patternStartIndex++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
var patternLength = (index - patternStartIndex - 1);
var pathLength = (pathEndIndex - pathStartIndex + 1);
var foundIndex = -1;
for (var i = 0; i <= pathLength - patternLength; i++)
{
var found = true;
for (var j = 0; j < patternLength; j++)
{
var subPat = patternParts[patternStartIndex + j + 1];
var subStr = pathParts[pathStartIndex + i + j];
if (!MatchStrings(subPat, subStr))
{
found = false;
break;
}
}
if (found)
{
foundIndex = pathStartIndex + i;
break;
}
}
if (foundIndex == -1)
{
return(false);
}
patternStartIndex = index;
pathStartIndex = foundIndex + patternLength;
}
for (var i = patternStartIndex; i <= patternEndIndex; i++)
{
if (patternParts[i] != "**")
{
return(false);
}
}
return(true);
}
