/// <summary>
/// Filtriranje liste XML nodova na osnovu zadate liste ključnih reči i vrednosti
/// </summary>
/// <param name="output">Lista XMLNodes koju će filtrirati komanda </param>
/// <param name="attributeNames">Lista imena atributa odnosno specijalne oznake</param>
/// <param name="attributeValues">Lista vrednosti svaki od imena atributa / izvora. Redosled je važan.</param>
/// <param name="matchPolicy">Vrsta testa vrednosti</param>
/// <param name="testMode">Kriterijum za ceo skup</param>
/// <param name="isInverted">Da li da koristi inverzni kriterijum</param>
/// <returns>Filtirana lista</returns>
public static List <XmlNode> filterNodeList(this List <XmlNode> output, List <String> attributeNames,
List <String> attributeValues,
stringMatchPolicy matchPolicy =
stringMatchPolicy.trimSpaceContainCaseFree,
collectionTestMode testMode = collectionTestMode.any,
Boolean isInverted = false)
{
List <XmlNode> filtered = new List <XmlNode>();
Boolean test = false;
foreach (XmlNode source in output)
{
test = compareAttributeValue(source, attributeNames, attributeValues, matchPolicy, testMode);
if (isInverted)
{
if (!test)
{
filtered.Add(source);
}
}
else
{
if (test)
{
filtered.Add(source);
}
}
}
return(filtered);
}
/// <summary>
/// Poređenje stringova korišćenjem imena stringMatchPolicy enuma
/// </summary>
/// <param name="operantA">Prvi operant</param>
/// <param name="operantB">Drugi operant</param>
/// <param name="compareMode">Ime stringMatchPolicy</param>
/// <returns>Rezultat</returns>
public static Boolean compareStrings(String operantA, String operantB, String compareMode)
{
stringMatchPolicy compare = stringMatchPolicy.trimSpaceCaseFree;
Enum.TryParse <stringMatchPolicy>(compareMode, out compare);
return(compareStrings(operantA, operantB, compare));
}
/// <summary>
/// Testira da li se u prosledjenom nodeu poklapa bar jedna vrednost attributa
/// </summary>
/// <param name="source">Node koji se testira</param>
/// <param name="attributeNames">DList spisak atributa ili @dataSource</param>
/// <param name="attributeValues">DList spisak vrednosti za svaki od atributa - redosled je bitan</param>
/// <returns></returns>
public static Boolean compareAttributeValue(this XmlNode source, String attributeNames, String attributeValues,
stringMatchPolicy matchPolicy =
stringMatchPolicy.trimSpaceContainCaseFree,
collectionTestMode testMode = collectionTestMode.any)
{
List <String> attNames = imbStringCommonTools.multiOpsInputProcessing(attributeNames);
List <String> attValues = imbStringCommonTools.multiOpsInputProcessing(attributeValues);
return(compareAttributeValue(source, attNames, attValues, matchPolicy, testMode));
}
/// <summary>
/// Uporedjuje string prema zadatom uslovu
/// </summary>
/// <param name="operantA">Search content - source</param>
/// <param name="operantB">Search needle - keyword</param>
/// <param name="compareMode"></param>
/// <returns></returns>
public static Boolean compareStrings(this String operantA, String operantB, stringMatchPolicy compareMode)
{
Boolean output = false;
if (operantA == null)
{
operantA = "";
}
if (operantB == null)
{
operantB = "";
}
switch (compareMode)
{
case stringMatchPolicy.caseFree:
output = (operantA.ToLower() == operantB.ToLower());
break;
case stringMatchPolicy.length:
output = (operantA.Length == operantB.Length);
break;
case stringMatchPolicy.lengthMore:
output = (operantA.Length > getLengthOrNumber(operantB));
break;
case stringMatchPolicy.lengthLess:
output = (operantA.Length <= getLengthOrNumber(operantB));
break;
case stringMatchPolicy.containCaseFree:
output = (operantA.ToLower().IndexOf(operantB.ToLower()) > -1);
break;
case stringMatchPolicy.similar:
output = (operantA == operantB);
if (!output)
{
operantA = operantA.ToLower();
operantB = operantB.ToLower();
output = (operantA == operantB);
}
if (!output)
{
output = (operantA.removeFromString(charsToIgnore_compareStrings) ==
operantB.removeFromString(charsToIgnore_compareStrings));
}
break;
case stringMatchPolicy.containExact:
output = (operantA.IndexOf(operantB) > -1);
break;
case stringMatchPolicy.trimSpaceExact:
operantA = operantA.Trim();
operantB = operantB.Trim();
output = (operantA == operantB);
break;
case stringMatchPolicy.trimSpaceCaseFree:
operantA = operantA.Trim();
operantB = operantB.Trim();
output = (operantA.ToLower() == operantB.ToLower());
break;
case stringMatchPolicy.trimSpaceContainExact:
operantA = operantA.Trim();
operantB = operantB.Trim();
output = (operantA.IndexOf(operantB) > -1);
break;
case stringMatchPolicy.trimSpaceContainCaseFree:
operantA = operantA.Trim().ToLower();
operantB = operantB.Trim().ToLower();
output = (operantA.ToLower().IndexOf(operantB.ToLower()) > -1);
break;
case stringMatchPolicy.overrideFalse:
output = false;
break;
case stringMatchPolicy.overrideTrue:
output = true;
break;
case stringMatchPolicy.exact:
default:
output = (operantA == operantB);
break;
}
return(output);
}
/// <summary>
/// Uporedjuje dva stringa pomocu datog string match policija
/// </summary>
/// <param name="compareMode">Nacin poredjenja</param>
/// <param name="operantA"></param>
/// <param name="operantB"></param>
/// <returns></returns>
public static Boolean compareStrings(this stringMatchPolicy compareMode, String operantA, String operantB)
{
return(operantA.compareStrings(operantB, compareMode));
}
/// <summary>
/// Testira da li se u prosledjenom nodeu poklapa bar jedna vrednost attributa
/// </summary>
/// <param name="source">Node koji se testira</param>
/// <param name="attNames">Lista imena atributa / odnosno specijalnih oznaka za izvor podatka</param>
/// <param name="attValues">Lista vrednosti za svaki od imena atributa - prema istom redosledu</param>
/// <returns></returns>
public static Boolean compareAttributeValue(this XmlNode source, List <String> attNames, List <String> attValues,
stringMatchPolicy matchPolicy =
stringMatchPolicy.trimSpaceContainCaseFree,
collectionTestMode testMode = collectionTestMode.any)
{
Int32 limit = attNames.Count;
XPathNavigator nav;
if (limit == 0)
{
return(true);
}
if (attValues.Count == 0)
{
return(true);
}
if (attValues.Count > limit)
{
limit = attValues.Count;
}
Int32 a = 0;
Boolean marked = false;
switch (testMode)
{
case collectionTestMode.any:
marked = false;
break;
case collectionTestMode.all:
marked = true;
break;
}
nav = source.CreateNavigator();
if (nav != null)
{
//if (nav.HasAttributes)
//{
for (a = 0; a < limit; a++)
{
String attName = "";
if (attNames.Count > a)
{
attName = attNames[a];
}
else
{
attName = attNames.Last();
}
String valName = "";
if (attValues.Count > a)
{
valName = attValues[a];
}
else
{
valName = attValues.Last();
}
String tmpVal = getNodeValueUniversal(source, attName); //nav.GetAttribute(attNames[a], "");
if (!String.IsNullOrEmpty(tmpVal))
{
Boolean test = imbStringOperations.compareStrings(tmpVal, valName, matchPolicy);
switch (testMode)
{
case collectionTestMode.any:
if (test)
{
marked = true;
a = limit;
}
break;
case collectionTestMode.all:
if (!test)
{
marked = false;
a = limit;
}
break;
}
}
}
//}
}
else
{
marked = false;
}
return(marked);
}
public static imbRegexQuery createCompareRegexQuery(this String operantB, stringMatchPolicy compareMode)
{
imbRegexQuery output = new imbRegexQuery();
switch (compareMode)
{
case stringMatchPolicy.caseFree:
output.expression = @"(\b|^)" + operantB + @"(\b|\Z)";
output.options = RegexOptions.IgnoreCase;
break;
case stringMatchPolicy.length:
output.expression = @"(\b|^)[\w]{" + operantB.Length + @"}(\b|\>)";
break;
case stringMatchPolicy.lengthMore:
output.expression = @"(\b|^)[\w]{" + operantB.Length + @",}(\b|\>)";
break;
case stringMatchPolicy.lengthLess:
output.expression = @"(\b|^)[\w]{1," + (operantB.Length - 1) + @"}(\b|\>)";
break;
case stringMatchPolicy.containCaseFree:
output.expression = operantB;
output.options = RegexOptions.IgnoreCase;
break;
case stringMatchPolicy.containExact:
output.expression = operantB;
break;
case stringMatchPolicy.trimSpaceExact:
output.expression = "^" + operantB.Trim() + @"\Z";
break;
case stringMatchPolicy.trimSpaceCaseFree:
output.expression = "^" + operantB.Trim();
output.options = RegexOptions.IgnoreCase;
break;
case stringMatchPolicy.trimSpaceContainExact:
output.expression = operantB.Trim();
break;
case stringMatchPolicy.trimSpaceContainCaseFree:
output.expression = operantB.Trim();
output.options = RegexOptions.IgnoreCase;
break;
case stringMatchPolicy.overrideFalse:
output.expression = "";
break;
case stringMatchPolicy.overrideTrue:
output.expression = ".";
break;
case stringMatchPolicy.exact:
default:
output.expression = "^" + operantB + @"\Z";
break;
}
return(output);
}
