private static IList <IOccurrence> StringOccurrences(string text, string pattern)
{
// Loop through all instances of the string 'text'.
IList <IOccurrence> occurrences = new Occurrences();
int i = 0;
while ((i = text.IndexOf(pattern, i)) != -1)
{
occurrences.Add(new Occurrence(i, i + pattern.Length));
i += pattern.Length;
}
return(occurrences);
}
private string ApplyString(string input, ChangeOptions options, IList <Change> exceptions)
{
string output = input;
if (!IsReplacementApplicable())
{
return(output);
}
Occurrences exceptionMatches = ExceptionMatches(input, exceptions);
if (options.Exceptions != null && options.Exceptions.Count > 0)
{
Occurrences innerExceptionMatches = ExceptionMatches(input, options.Exceptions);
if (innerExceptionMatches.Count > 0)
{
exceptionMatches.AddRange(innerExceptionMatches);
}
}
int replacementCount = GetReplacementCount(options);
if (replacementCount == 0)
{
return(output);
}
if (exceptionMatches.Count == 0)
{
if (replacementCount == -1)
{
output = input.Replace(Pattern, Replace);
}
else
{
int count = replacementCount;
output = Output(options, count, exceptionMatches, output);
}
}
else
{
int count = (replacementCount == -1) ? input.Length : replacementCount;
output = Output(options, count, exceptionMatches, output);
}
return(output);
}
private static Occurrences ExceptionMatches(string input, IList <Expression> exceptions)
{
Occurrences exceptionMatches = new Occurrences();
if (exceptions == null || (exceptions.Count == 0))
{
return(exceptionMatches);
}
foreach (Expression exception in exceptions)
{
foreach (Occurrence pointer in exception.Occurrences(input))
{
exceptionMatches.Add(pointer);
}
}
return(exceptionMatches);
}
/// <summary>
/// Applies change in regular expression format to input string.
/// </summary>
/// <param name="input"></param>
/// <param name="options"></param>
/// <param name="exceptions"></param>
/// <returns></returns>
private string ApplyRegex(string input, ChangeOptions options, IList <Change> exceptions)
{
if (!IsReplacementApplicable())
{
return(input); //nedochází k žádné změně
}
//pravidla počtu nahrazení pro Regex: -1 = všechny výskyty; 0 = žádný výskyt; 1 a více = zadaný počet výskytů
//pravdila Cahnge: null, 0 = žádný výskyt
string output = input;
int replacementCount = GetReplacementCount(options);
Occurrences exceptionMatches = ExceptionMatches(input, exceptions);
if (exceptionMatches.Count == 0)
{
return(base.Regex.Replace(input, Replace, replacementCount));
}
MatchCollection patternMatches = base.Regex.Matches(input);
int count = 0;
output = input;
foreach (Match match in patternMatches)
{
Occurrence occurrence = new Occurrence(match.Index, match.Index + match.Length);
if (!exceptionMatches.IsOccurrenceWithin(occurrence))
{
output = base.Regex.Replace(output, Replace, 1, match.Index);
count++;
}
if (count == options.ReplacementCount)
{
return(output);
}
}
return(output);
}
private string Output(ChangeOptions options, int count, Occurrences exceptionMatches, string output)
{
int start = 0;
for (int i = 0; i < count; i++)
{
int loc = output.IndexOf(Pattern, start, StringComparison.Ordinal);
Occurrence occurrence = new Occurrence(loc, loc + Pattern.Length);
while (exceptionMatches.IsOccurrenceWithin(occurrence))
{
loc = output.IndexOf(Pattern, loc + 1, StringComparison.Ordinal);
occurrence = new Occurrence(loc, loc + Pattern.Length);
}
if (loc == -1)
{
return(output);
}
output = ReplaceFirstOccurrence(output, Pattern, Replace, options, loc);
start = loc + 1;
}
return(output);
}
/// <summary>
/// Pointers to start indexes in the input, where patterns starts.
/// </summary>
/// <param name="input">Input text in which the pattern is searched.</param>
/// <returns>List of integers. If there is no pattern match, empty list is returned.</returns>
// při porovnánání výjimky se pak zjišťuje, jestli výskyt je mezi těmito krajními body
public IList <IOccurrence> Occurrences(string input)
{
IList <IOccurrence> occurences = new Occurrences();
switch (Format)
{
case ChangeFormat.String:
occurences = StringOccurrences(input, Pattern);
break;
case ChangeFormat.RegularExpression:
MatchCollection matches = _regex.Matches(input);
foreach (Match match in matches)
{
occurences.Add(new Occurrence(match.Index, match.Index + match.Length));
}
break;
default:
throw new ArgumentOutOfRangeException();
}
return(occurences);
}
