internal static BinaryExpression ApplyCompareOperation(
ComparatorType comparatorType,
Expression getValueExp,
Expression getFilterExp)
{
switch (comparatorType)
{
case ComparatorType.Equal:
return(Expression.Equal(getValueExp, getFilterExp));
case ComparatorType.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(getValueExp, getFilterExp));
case ComparatorType.GreaterThan:
return(Expression.GreaterThan(getValueExp, getFilterExp));
case ComparatorType.LessThan:
return(Expression.LessThan(getValueExp, getFilterExp));
case ComparatorType.LessThanOrEqual:
return(Expression.LessThanOrEqual(getValueExp, getFilterExp));
default:
goto case ComparatorType.Equal;
}
}
public override void UpdatePersistentData()
{
_propertyNamePers = null;
_comparatorPers = ComparatorType.Equals;
_targetValuePers = null;
_methodParameterPers = null;
// Save property name, not index
if (_propertyIndex < PropertyList.Length)
{
_propertyNamePers = PropertyList[_propertyIndex];
}
_comparatorPers = _comparator;
// Target value
if (_targetValue != null)
{
_targetValuePers = _targetValue.ValueStr;
}
// Parameters
if (_methodParameter != null)
{
_methodParameterPers = new string[_methodParameter.Length];
for (int i = 0; i < _methodParameter.Length; i++)
{
_methodParameterPers[i] = _methodParameter[i].ValueStr;
}
}
}
public bool CompareFrom(object other, ComparatorType ope)
{
switch (ope)
{
case ComparatorType.Equals:
return(_value.Equals(other));
case ComparatorType.NotEquals:
return(!_value.Equals(other));
case ComparatorType.Less:
return(_comparable ? ((_value as IComparable).CompareTo(other) > 0) : false);
case ComparatorType.LessOrEquals:
return(_comparable ? ((_value as IComparable).CompareTo(other) >= 0) : false);
case ComparatorType.More:
return(_comparable ? ((_value as IComparable).CompareTo(other) < 0) : false);
case ComparatorType.MoreOrEquals:
return(_comparable ? ((_value as IComparable).CompareTo(other) <= 0) : false);
default:
return(false);
}
}
public TriggerConditionFlight(VesselTriggers vesselTriggers) : base(vesselTriggers)
{
_type = TriggerConditionType.Flight;
_propertyIndex = -1;
_fieldInfo = null;
_propertyInfo = null;
_methodInfo = null;
_propertySource = null;
_methodParameter = null;
_comparator = ComparatorType.Equals;
_targetValue = null;
}
public static IComparator GetComparator(ComparatorType type)
{
switch (type)
{
case ComparatorType.CharByCharComparator:
return(new CharByCharComparator());
case ComparatorType.ContainsComparator:
return(new ContainsComparator());
case ComparatorType.EditDistanceComparator:
return(new EditDistanceComparator());
}
return(null);
}
public DataTable GetResultComparisonByType(ComparatorType type, DataTable fromDataTable, DataTable withDataTable, bool distinct)
{
switch (type)
{
case ComparatorType.Different:
return(GetBetweenDifferentData(fromDataTable, withDataTable, distinct));
case ComparatorType.Equals:
return(GetBetweenEqualData(fromDataTable, withDataTable, distinct));
case ComparatorType.Merge:
return(GetMergeData(fromDataTable, withDataTable, distinct));
default:
throw new NotImplementedException();
}
}
private Dictionary <string, QueryColumn> GetFilterInfo(int filterTargetId, SqlConnection connection, string[] queryWords)
{
Dictionary <string, QueryColumn> dict = new Dictionary <string, QueryColumn>(); // key - queryWord
string qwords = FormatQueryWords(queryWords);
string q = $"Select f.QueryWord, f.FilterColumnName, f.Comparator from [dbo].[Filters] as f where f.FilterTargetId = {filterTargetId} and f.QueryWord in ({qwords})";
SqlCommand cmd2 = new SqlCommand(q, connection);
using (SqlDataReader dr = cmd2.ExecuteReader())
{
while (dr.Read())
{
ComparatorType comparator = (ComparatorType)Enum.Parse(typeof(ComparatorType), (string)dr["Comparator"], true);
dict.Add(dr["QueryWord"].ToString(), new QueryColumn(dr["FilterColumnName"].ToString(), comparator));
}
}
return(dict);
}
public static String ComparatorTypeToString(ComparatorType comparatorType)
{
switch (comparatorType)
{
case ComparatorType.LessThan:
return "<";
break;
case ComparatorType.GreaterThan:
return ">";
break;
case ComparatorType.LessThanOrEqualThan:
return "<=";
break;
case ComparatorType.GreaterThanOrEqualTo:
return ">=";
break;
case ComparatorType.Equals:
return "=";
break;
case ComparatorType.NotEqualTo:
return "<>";
break;
case ComparatorType.Between:
return "BETWEEN";
break;
case ComparatorType.NotBetween:
return "NOT BETWEEN";
break;
case ComparatorType.Like:
return "LIKE";
break;
case ComparatorType.NotLike:
return "NOT LIKE";
break;
case ComparatorType.In:
return "IN";
break;
case ComparatorType.NotIn:
return "NOT IN";
break;
default:
throw new ArgumentOutOfRangeException("comparatorType");
}
}
public SeedComparatorType(ComparatorType t)
{
switch (t)
{
case ComparatorType.MinimizeExitDepth:
comparison = delegate(int bestSeed, int newSeed)
{
int d = Util.GetExitDepth();
if (bestDepth < d)
{
int r = d - bestDepth;
bestDepth = d;
return(r);
}
return(d - bestDepth);
};
break;
}
}
public TriggerConditionFlight(TriggerConditionFlight other) : base(other)
{
_type = TriggerConditionType.Flight;
// Automatic call of PropertyIndex_set
PropertyIndex = other._propertyIndex;
_comparator = other._comparator;
if (other._targetValue != null)
{
_targetValue.ValueStr = other._targetValue.ValueStr;
}
if (_methodParameter != null)
{
for (int i = 0; i < _methodParameter.Length; i++)
{
_methodParameter[i].ValueStr = other._methodParameter[i].ValueStr;
}
}
UpdatePersistentData();
}
public TriggerConditionPart(TriggerConditionPart other) : base(other)
{
_type = TriggerConditionType.Part;
_part = null;
// Automatic call of Part_set
ConditionPart = other._part;
// Automatic call of PropertyIndex_set
PropertyIndex = other._propertyIndex;
_comparator = other._comparator;
if ((_targetValue != null) && other._targetValue != null)
{
_targetValue.ValueStr = other._targetValue.ValueStr;
}
if (_methodParameter != null)
{
for (int i = 0; i < _methodParameter.Length; i++)
{
_methodParameter[i].ValueStr = other._methodParameter[i].ValueStr;
}
}
_currentValue = null;
UpdatePersistentData();
}
public TermsFacetBuilder Order(ComparatorType type)
{
_comparatorType = type;
return(this);
}
public TermsFacetBuilder(string name) : base(name)
{
_comparatorType = ComparatorType.COUNT;
}
protected Comparator(ComparatorType comparatorType)
{
ComparatorType = comparatorType;
}
public QueryColumn(string columnName, ComparatorType comparator)
{
ColumnName = columnName;
Comparator = comparator;
}
public TermsFacetBuilder(string name)
: base(name)
{
_comparatorType = ComparatorType.COUNT;
}
public TermsFacetBuilder Order(ComparatorType type)
{
_comparatorType = type;
return this;
}
protected Comparator(ComparatorType comparatorType)
{
ComparatorType = comparatorType;
}
/// <summary>
/// Creates a Comparator object using the specified ComparatorType.
/// </summary>
/// <param name="comparatorType">The type of compare operation this Comparator object is to perform.</param>
internal Comparator( ComparatorType comparatorType )
{
_comparatorType = comparatorType;
NumberOfParameters = 2;
}
public bool ComparatorValid(ComparatorType ope)
{
return(_comparable || (ope == ComparatorType.Equals) || (ope == ComparatorType.NotEquals));
}