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 Order(ComparatorType type) { _comparatorType = type; return this; }
/// <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)); }