private static List <FilterItem> GetFilters(string input,
Match match,
ReplaceTemplateItem item)
{
List <FilterItem> lstFilter = new List <FilterItem>();
foreach (DataRow drWhen in item.When)
{
bool action = false;
if (drWhen.IsNull("action"))
{
action = (bool)drWhen.Table.Columns["action"].DefaultValue;
}
else
{
action = (bool)drWhen["action"];
}
string pattern = ReplaceUtils.GetRegexPattern(drWhen);
//pattern = ReplaceReference.Reference(pattern, match);
RegexOptions options = ReplaceUtils.GetRegexOptions(drWhen);
Regex reg = new Regex(pattern, options);
if (reg != null)
{
GetFilters(input, reg, action, lstFilter);
}
}
return(lstFilter);
}
/// <summary>
/// Trim Reference of Replacement.ReplacePairs to Const Strings.
/// <remarks>
/// e.g
/// [$ABCD$] => ABCD
/// </remarks>
/// </summary>
public static void Reference(ReplaceTemplateItem rep)
{
foreach (DataRow row in rep.Replace)
{
//f2[kv.Key] = Reference(kv.Value);
}
//CollectionUtil.Combine(f2, rep.ReplacePairs);
}
public static ReplaceTemplateItem GetTemplateItem(DataRow drTemplateType)
{
ReplaceTemplateItem template = new ReplaceTemplateItem();
template.Pattern = drTemplateType.GetChildRows("item_pattern")[0];
template.Replace = drTemplateType.GetChildRows("item_replace");
template.When = drTemplateType.GetChildRows("item_when");
return(template);
}
public static bool CanReplace(string input,
Match match,
ReplaceTemplateItem item)
{
List <FilterItem> lstFilter = GetFilters(input, match, item);
if (lstFilter.Count == 0)
{
return(true);
}
return(!lstFilter.Any(filter => filter.Index <= match.Index &&
match.Index + match.Length <= filter.Index + filter.Length &&
!filter.Enable));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="item"></param>
private void LoadItemXml(XmlNode node, ReplaceTemplateItem item)
{
//item.Pattern = node.SelectSingleNode("pattern").InnerText.Trim();
//foreach (XmlNode repNode in node.SelectNodes("replace"))
//{
// string value = repNode.InnerText;
// string group = Xmler.GetAttribute(repNode, "group");
// int groupindex;
// if (int.TryParse(group, out groupindex))
// {
// item.ReplacePairs[groupindex] = repNode.InnerText.Trim();
// }
//}
//// Load Item Private Filters
//CollectionUtil.Combine(GetFilters(node), item.Filters);
}
/// <summary>
/// Replacement refercences Match.
/// </summary>
/// <param name="replacement"></param>
/// <param name="match"></param>
public static void ReferenceDictionary(ReplaceTemplateItem replacement, Match match)
{
string pattern = string.Empty;
string replace = string.Empty;
Dictionary <int, string> pair = new Dictionary <int, string>();
//foreach (KeyValuePair<int, string> kv in replacement.ReplacePairs)
//{
// replace = kv.Value;
// //================================
// replace = Reference(replace, match, kv.Key, replacement.Dictionary);
// replace = Reference(replace, match);
// //================================
// pair[kv.Key] = replace;
//}
//replacement.ReplacePairs.Clear();
//CollectionUtil.Combine(pair, replacement.ReplacePairs);
}
/// <summary>
/// Replacement refercences Match.
/// </summary>
/// <param name="replacement"></param>
/// <param name="match"></param>
public static Dictionary <int, string> Reference(ReplaceTemplateItem replacement, Match match)
{
string replace = string.Empty;
Dictionary <int, string> pair = new Dictionary <int, string>();
//foreach (KeyValuePair<int, string> kv in replacement.ReplacePairs)
//{
// replace = kv.Value;
// //================================
// if (replace.Equals("#REFRENCE_DIC_COMPLETE"))
// {
// replace = match.Groups[kv.Key].Value;
// replace = CollectionUtil.GetValue(replacement.Dictionary, replace);
// }
// replace = Reference(replace, match);
// //================================
// pair[kv.Key] = replace;
//}
return(pair);
}
/// <summary>
/// Replacement refercences Dictionary<name, value>.
/// </summary>
/// <param name="rep"></param>
/// <param name="args"></param>
public static void Reference(ReplaceTemplateItem rep, Dictionary <string, string> args)
{
string refargs = Parameters.Instance["refargs"];
if (string.IsNullOrEmpty(refargs))
{
return;
}
// Check Pattern
//rep.Pattern = Reference(rep.Pattern, refargs, args);
//========================================================
// Check Filters
string key = string.Empty;
Dictionary <string, bool> tFilters = new Dictionary <string, bool>();
//foreach (KeyValuePair<string, bool> kv in rep.Filters)
//{
// key = Reference(kv.Key, refargs, args);
// tFilters[key] = kv.Value;
//}
//rep.Filters.Clear();
//CollectionUtil.Combine(tFilters, rep.Filters);
//========================================================
// Check ReplacePairs
//Dictionary<int, string> f2 = new Dictionary<int, string>();
//string value = string.Empty;
//foreach (KeyValuePair<int, string> kv in rep.ReplacePairs)
//{
// f2[kv.Key] = Reference(kv.Value, refargs, args);
//}
//rep.ReplacePairs.Clear();
//CollectionUtil.Combine(f2, rep.ReplacePairs);
}
public static string ReplaceGroup(string input, ReplaceTemplateItem replacement)
{
return(DefaultReplacer.Replace(input, replacement));
}
