/// <summary>
/// This method returns the Comparison Text for the ComparisonType given.
/// </summary>
public string GetComparisonText(ComparisonTypeEnum comparisonType)
{
// initial value
string comparisonText = "";
// determine the return value based upon a comparisonType
switch (comparisonType)
{
case ComparisonTypeEnum.LessThan:
// set the return value
comparisonText = "is less than";
// required
break;
case ComparisonTypeEnum.LessThanOrEqual:
// set the return value
comparisonText = "is less than or equal to";
// required
break;
case ComparisonTypeEnum.Equal:
// set the return value
comparisonText = "is equal to";
// required
break;
case ComparisonTypeEnum.GreaterThanOrEqual:
// set the return value
comparisonText = "is greater than or equal";
// required
break;
case ComparisonTypeEnum.GreaterThan:
// set the return value
comparisonText = "is greater than";
// required
break;
case ComparisonTypeEnum.NotEqual:
// set the return value
comparisonText = "is not equal to";
// required
break;
}
// return value
return(comparisonText);
}
/// <summary>
/// Compares the in.
/// </summary>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="compareType">Type of the compare.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool CompareIn(string left, string right, ComparisonTypeEnum compareType)
{
var list = right.Split(new char[] { '|' }, StringSplitOptions.None);
if (compareType == ComparisonTypeEnum.Datetime)
{
return(CompareDateTime(left, list));
}
return(list.Contains(left));
}
/// <summary>
/// Create a new instance of an IfStatement object and set the properties.
/// </summary>
/// <param name="source"></param>
/// <param name="comparisonType"></param>
/// <param name="target"></param>
public IfStatement(string source, ComparisonTypeEnum comparisonType, string target, int level)
{
// Set the properties
this.Source = source;
this.ComparisonType = comparisonType;
this.Target = target;
this.Level = level;
// Perform initializations for this object
Init();
}
/// <summary>
/// This method returns the Comparison Type
/// </summary>
private static ComparisonTypeEnum GetComparisonType(string op)
{
// initial value
ComparisonTypeEnum comparisonType = ComparisonTypeEnum.NotSet;
// determine the operator
switch (op)
{
case ">":
// set the return value
comparisonType = ComparisonTypeEnum.GreaterThan;
// required
break;
case ">=":
// set the return value
comparisonType = ComparisonTypeEnum.GreaterThanOrEqual;
// required
break;
case "==":
// set the return value
comparisonType = ComparisonTypeEnum.Equal;
// required
break;
case "<=":
// set the return value
comparisonType = ComparisonTypeEnum.LessThanOrEqual;
// required
break;
case "<":
// set the return value
comparisonType = ComparisonTypeEnum.LessThan;
// required
break;
}
// return value
return(comparisonType);
}
/// <summary>
/// Compares the starts with.
/// </summary>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="compareType">Type of the compare.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool CompareStartsWith(string left, string right, ComparisonTypeEnum compareType)
{
var list = right.Split(new char[] { '|' }, StringSplitOptions.None);
if (compareType == ComparisonTypeEnum.Datetime)
{
return(CompareDateTime(left, right));
}
throw new NotImplementedException("Compare option not implimented.");
#pragma warning disable CS0162 // Unreachable code detected
return(left == right);
#pragma warning restore CS0162 // Unreachable code detected
}
/// <summary>
/// Compares the equal.
/// </summary>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="compareType">Type of the compare.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool CompareEqual(string left, string right, ComparisonTypeEnum compareType, int leftZone, int rightZone)
{
var list = right.Split(new char[] { '|' }, StringSplitOptions.None);
if (compareType == ComparisonTypeEnum.Datetime)
{
return(CompareDateTime(left, right, leftZone, rightZone));
}
else if (compareType == ComparisonTypeEnum.Date)
{
return(CompareDate(left, right));
}
else if (compareType == ComparisonTypeEnum.Integer)
{
return(CompareInteger(left, right));
}
return(left == right);
}
/// <summary>
/// Determines whether the specified left is equal.
/// </summary>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="compareType">Type of the compare.</param>
/// <param name="operator">The operator.</param>
/// <returns><c>true</c> if the specified left is equal; otherwise, <c>false</c>.</returns>
public static bool IsEqual(string left, string right, ComparisonTypeEnum compareType, OperatorEnums @operator, string ignoreChars, int leftZone, int rightZone)
{
right = string.IsNullOrEmpty(right) ? string.Empty : right;
left = string.IsNullOrEmpty(left) ? string.Empty : left;
ignoreChars = string.IsNullOrEmpty(ignoreChars) ? string.Empty : ignoreChars;
ignoreChars.ToList().ForEach(@char => right = right.Replace(@char, ' '));
ignoreChars.ToList().ForEach(@char => left = left.Replace(@char, ' '));
if (@operator == OperatorEnums.In)
{
return(CompareIn(left, right, compareType));
}
if (@operator == OperatorEnums.Table)
{
return(CompareTable(left, right, compareType, leftZone, rightZone));
}
if (@operator == OperatorEnums.Equals)
{
return(CompareEqual(left, right, compareType, leftZone, rightZone));
}
if (@operator == OperatorEnums.StartsWidth)
{
return(right.StartsWith(left));
}
if (@operator == OperatorEnums.EndsWidth)
{
return(right.EndsWith(left));
}
if (@operator == OperatorEnums.Contains)
{
return(right.Contains(left));
}
return(false);
}
/// <summary>
/// Compares the tabe.
/// </summary>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="compareType">Type of the compare.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool CompareTable(string left, string right, ComparisonTypeEnum compareType, int leftZone, int rightZone)
{
List <string> date1 = new List <string>();
List <string> date2 = new List <string>();
var list1 = left.Split(new char[] { '|' }, StringSplitOptions.None);
var list2 = right.Split(new char[] { '|' }, StringSplitOptions.None);
if (compareType == ComparisonTypeEnum.Datetime)
{
foreach (var item in list1)
{
DateTime.TryParse(item, out DateTime d1);
date1.Add(d1.AddHours(leftZone).ToString());
}
foreach (var item in list2)
{
DateTime.TryParse(item, out DateTime d2);
date2.Add(d2.AddHours(rightZone).ToString());
}
left = string.Join("|", date1.ToArray());
right = string.Join("|", date2.ToArray());
list1 = left.Split(new char[] { '|' }, StringSplitOptions.None);
list2 = right.Split(new char[] { '|' }, StringSplitOptions.None);
}
var o1 = string.Join("|", list1.OrderBy(o => o));
var o2 = string.Join("|", list2.OrderBy(o => o));
return(o1 == o2);
// var count1 = list1.Except(list2).Count();
//var count1 = list1.Except(list2).Count();
//return list1.Except(list2).Count() == 0 && list2.Except(list1).Count() == 0;
}
/// <summary>
/// Конструктор, вызываемый при создании фильтра-предиката
/// для составных типов данных, содержащих определение свойства <paramref name="propName"/>.
/// </summary>
/// <param name="propName">Наименование свойства объекта типа <see cref="{T}"/>, по которому необходимо выполнить фильтрацию.</param>
/// <param name="comparison">Тип операции сравнения.</param>
/// <param name="val">Объект, с которым сравнивается значение свойства <paramref name="propName"/>.</param>
public QFilter(string propName, ComparisonTypeEnum comparison, object val)
{
PropName = propName;
Comparison = comparison;
Value = val;
}
/// <summary>
/// Конструктор, вызываемый при создании фильтра-предиката
/// для простых (не составных) типов данных, не имеющих определений свойств.
/// </summary>
/// <param name="comparison">Тип операции сравнения.</param>
/// <param name="val">Объект, с которым сравнивается значение элементов списка.</param>
public QFilter(ComparisonTypeEnum comparison, object val)
{
PropName = null;
Comparison = comparison;
Value = val;
}
/// <summary>
/// This method attempts to parse an IfStatement object out of the sourceCode given.
/// </summary>
public static IfStatement ParseIfStatement(string sourceCode, int level = 1)
{
// initial value
IfStatement ifStatement = null;
// local
int openParenCount = 0;
int closeParenCount = 0;
int openParenIndex = 0;
int closeParenIndex = 0;
char openParen = OpenParenString[0];
char closeParen = CloseParenString[0];
int len = 0;
string innerCode = "";
string source = "";
string op = "";
string target = "";
ComparisonTypeEnum comparisonType = ComparisonTypeEnum.NotSet;
// if the sourceCode exists
if (!String.IsNullOrEmpty(sourceCode))
{
// trim the sourceCode
sourceCode = sourceCode.Trim();
// if this is an ifStatement
if (sourceCode.StartsWith("if"))
{
// set the count of each character to make sure we have a valid ifStatement
openParenCount = GetOccurrencesOfChar(sourceCode, openParen);
closeParenCount = GetOccurrencesOfChar(sourceCode, closeParen);
// if this is a 'Simple' IfStatement
if ((openParenCount == closeParenCount) && (openParenCount == 1))
{
// get the index of the openParen
openParenIndex = sourceCode.IndexOf(openParen);
closeParenIndex = sourceCode.IndexOf(closeParen);
len = closeParenIndex - openParenIndex - 1;
// set the inner code
innerCode = sourceCode.Substring(openParenIndex + 1, len);
// if the innerCode exists
if (!String.IsNullOrEmpty(innerCode))
{
// get the words
List <Word> words = CSharpCodeParser.ParseWords(innerCode);
// if the words collection existsre are exactly 3 words
if (words != null)
{
// if there is only one word
if (words.Count == 1)
{
// set the sourceWord
source = words[0].Text;
// if this is a NotComparison
bool isEqual = (!source.StartsWith("!"));
// create the ifStatement
ifStatement = new IfStatement(source, isEqual, level);
}
// if there are exactly 3 words
else if (words.Count == 3)
{
// parse out the items that build the ifStatement
source = words[0].Text;
op = words[1].Text;
target = words[2].Text;
// Get the comparisonType for the operator
comparisonType = IfStatementParser.GetComparisonType(op);
// now create the ifStatement
ifStatement = new IfStatement(source, comparisonType, target, level);
}
}
}
}
}
}
// return value
return(ifStatement);
}
/// <summary>
/// This method returns the Comparison Type
/// </summary>
public static ComparisonTypeEnum SetComparisonType(string text, ref PixelCriteria pixelCriteria)
{
// initial value
ComparisonTypeEnum comparisonType = ComparisonTypeEnum.Unknown;
// locals
int number1 = -1000;
int number2 = -1000;
int number3 = -1000;
int number4 = -1000;
// if the text exists
if ((TextHelper.Exists(text)) && (NullHelper.Exists(pixelCriteria)))
{
// drawing is different for DrawLine
if (pixelCriteria.PixelType == PixelTypeEnum.DrawLine)
{
// Parse out the numbers from the text
ParseNumbers(text, ref number1, ref number2, ref number3, ref number4);
// Set the Start and End Point
pixelCriteria.StartPoint = new Point(number1, number2);
pixelCriteria.EndPoint = new Point(number3, number4);
}
else
{
// Parse out the numbers from the text
ParseNumbers(text, ref number1, ref number2);
// if the text contains less than
if (text.Contains("<"))
{
// Set to Less Than
comparisonType = ComparisonTypeEnum.LessThan;
// Set the MaxValue
pixelCriteria.MaxValue = number1;
}
// if the text contains between
else if (text.Contains("between"))
{
// Set to Between
comparisonType = ComparisonTypeEnum.Between;
// Set the MinValue
pixelCriteria.MinValue = number1;
// Set the MaxValue
pixelCriteria.MaxValue = number2;
}
// if the text contains greater than
else if (text.Contains(">"))
{
// Set to Greater Than
comparisonType = ComparisonTypeEnum.GreaterThan;
// Set the MinValue
pixelCriteria.MinValue = number1;
}
else if (text.Contains("="))
{
// Set to Equals
comparisonType = ComparisonTypeEnum.Equals;
// Set the TargetValue
pixelCriteria.TargetValue = number1;
}
}
// set the comparisonType on the object passed in
pixelCriteria.ComparisonType = comparisonType;
}
// return value
return(comparisonType);
}
