public INumberMatch Initialize( IValueGetter valueGetter, CompareOperation compareOperation, int match, bool inverted = false, int defaultValue = 0) { _match = match; _valueGetter = valueGetter; _compareOperation = compareOperation; _inverted = inverted; _defaultValue = defaultValue; switch (compareOperation) { case CompareOperation.Equals: _testFunc = (ruleResult, number) => number == _match; break; case CompareOperation.Less: _testFunc = (ruleResult, number) => number < _match; break; case CompareOperation.Greater: _testFunc = (ruleResult, number) => number > _match; break; default: throw new Exception("Number match does not know how to compare numbers using " + compareOperation); } return(this); }
public override void CopyFrom(Action copy) { base.CopyFrom(copy); Value = (copy as ActionConditionBufferSize).Value; Operation = (copy as ActionConditionBufferSize).Operation; }
public static bool Calculate <T> (T value1, CompareOperation operation, T value2) where T : IComparable <T>, IEquatable <T> { //OPTIMIZE: box化,unbox化が走るので、気になるならTをstructにするなど switch (operation) { case CompareOperation.Equal: return(value1.Equals(value2)); case CompareOperation.NotEqual: return(!value1.Equals(value2)); case CompareOperation.Greater: return(value1.CompareTo(value2) > 0); case CompareOperation.Less: return(value1.CompareTo(value2) < 0); case CompareOperation.GreaterThanOrEqualTo: return(value1.CompareTo(value2) >= 0); case CompareOperation.LessThanOrEqualTo: return(value1.CompareTo(value2) <= 0); default: Debug.LogErrorFormat("unexpected operation type {0}", operation); return(true); } }
public Var_CompareOp(IEffect effectA, int con, CompareOperation op) { EffectA = effectA; EffectB = null; ConstantInt = con; this.op = op; }
public static string ToShortString(this CompareOperation operation) { switch (operation) { case CompareOperation.Equal: return("EQ"); case CompareOperation.NotEqual: return("NOT"); case CompareOperation.Greater: return("GT"); case CompareOperation.Less: return("LT"); case CompareOperation.GreaterThanOrEqualTo: return("GTE"); case CompareOperation.LessThanOrEqualTo: return("LTE"); default: Debug.LogErrorFormat("unexpected operation type {0}", operation); return(""); } }
public static string ToMarkString(this CompareOperation operation) { switch (operation) { case CompareOperation.Equal: return("=="); case CompareOperation.NotEqual: return("!="); case CompareOperation.Greater: return(">"); case CompareOperation.Less: return("<"); case CompareOperation.GreaterThanOrEqualTo: return(">="); case CompareOperation.LessThanOrEqualTo: return("<="); default: Debug.LogErrorFormat("unexpected operation type {0}", operation); return(""); } }
public static ReportConditionDef AddAttributeCondition(this ReportDef def, Guid leftSourceId, Guid leftAttrId, CompareOperation condition, Guid rightSourceId, Guid rightAttrId) { Check(def); CheckSourceAttribute(def, leftSourceId, leftAttrId); CheckSourceAttribute(def, rightSourceId, rightAttrId); var conditionId = Guid.NewGuid(); var conditionDef = new ReportConditionDef { Id = conditionId, Operation = ExpressionOperation.And, LeftAttribute = new ReportAttributeDef { SourceId = leftSourceId, AttributeId = leftAttrId }, Condition = condition, RightPart = new ReportConditionRightAttributeDef { Attribute = new ReportAttributeDef { SourceId = rightSourceId, AttributeId = rightAttrId } } }; def.Conditions.Add(conditionDef); return(conditionDef); }
public static bool TryGet(ExpressionType expressionType, out CompareOperation compareOperation) { switch (expressionType) { case ExpressionType.Equal: compareOperation = CompareOperation.Equal; return true; case ExpressionType.NotEqual: compareOperation = CompareOperation.NotEqual; return true; case ExpressionType.GreaterThan: compareOperation = CompareOperation.GreaterThan; return true; case ExpressionType.GreaterThanOrEqual: compareOperation = CompareOperation.GreaterThanOrEqual; return true; case ExpressionType.LessThan: compareOperation = CompareOperation.LessThan; return true; case ExpressionType.LessThanOrEqual: compareOperation = CompareOperation.LessThanOrEqual; return true; } compareOperation = CompareOperation.Equal; return false; }
public static bool EvaluateCompareExpression(int target, int compareValue, CompareOperation operation) { switch (operation) { case CompareOperation.Equal: return(target == compareValue); case CompareOperation.NotEqual: return(target != compareValue); case CompareOperation.GreaterThan: return(target > compareValue); case CompareOperation.GreaterOrEqualThan: return(target >= compareValue); case CompareOperation.LessThan: return(target < compareValue); case CompareOperation.LessOrEqualThan: return(target <= compareValue); default: throw new Exception("Unknown Operation"); } }
public void Comparison_Objects(TestObject a, CompareOperation operation, TestObject b, TestExceptionType eType) { IComparable objA = (IComparable)a.GetObject(); IComparable objB = (IComparable)b.GetObject(); this.RunTest(() => this.Checker.Comparison(objA, operation, objB), eType); }
public static TokenType GetOperatorTokenType(CompareOperation operation) { switch (operation) { case CompareOperation.Equal: return(TokenType.Equal); case CompareOperation.NotEqual: return(TokenType.NotEqual); case CompareOperation.Greater: return(TokenType.Greater); case CompareOperation.GreaterOrEqual: return(TokenType.GreaterOrEqual); case CompareOperation.Less: return(TokenType.Less); case CompareOperation.LessOrEqual: return(TokenType.LessOrEqual); default: throw new ArgumentOutOfRangeException(nameof(operation), operation, "Unknown enumeration value."); } }
public override void LoadParameters(System.IO.BinaryReader reader) { //GameManager.DebugLog("Loading Modify"); base.LoadParameters(reader); target_resource_index = reader.ReadInt32(); operation_resource_index = reader.ReadInt32(); target = (ResourceSource)reader.ReadInt32(); param1 = (ResourceSource)reader.ReadInt32(); param2 = (ResourceSource)reader.ReadInt32();; operation = (CompareOperation)reader.ReadInt32(); action_mod = reader.ReadString(); bool_mod = reader.ReadBoolean(); text_mod = reader.ReadString(); number_mod = reader.ReadInt32(); action_mod2 = reader.ReadString(); bool_mod2 = reader.ReadBoolean(); text_mod2 = reader.ReadString(); number_mod2 = reader.ReadInt32(); //trigger = (CGME.InterfaceEvent)Enum.Parse(typeof(InterfaceEvent),reader.ReadString()); }
public static bool Compare <T>(this CompareOperation operation, T a, T b) where T : IComparable { bool bothNull = a == null && b == null; switch (operation) { case CompareOperation.Equal: return(bothNull || (a != null && a.CompareTo(b) == 0)); case CompareOperation.Greater: return(!bothNull && a != null && a.CompareTo(b) > 0); case CompareOperation.GreaterEqual: return(bothNull || (a != null && a.CompareTo(b) >= 0)); case CompareOperation.Less: return(!bothNull && (a == null || a.CompareTo(b) < 0)); case CompareOperation.LessEqual: return(bothNull || a == null || a.CompareTo(b) <= 0); default: throw new ArgumentOutOfRangeException(nameof(operation), operation, null); } }
public override void LoadParameters(System.IO.BinaryReader reader) { base.LoadParameters(reader); Value = reader.ReadInt32(); Operation = (CompareOperation)reader.ReadInt32(); }
/// <inheritdoc /> public override string ToEncodedString() { const string filterPattern = @"{{""type"":""RowFilter"",""op"":""{0}"",""comparator"":{{{1}}}}}"; return(string.Format(CultureInfo.InvariantCulture, filterPattern, CompareOperation.ToCodeName(), Comparator.ToEncodedString())); }
static void Main(string[] args) { CompareOperation op = ComparingTwo; ComparingTwo(6, 3); Console.ReadKey(); }
public IEnumerable<IKey> Match(string path, CompareOperation operation, object value) { ITableIndex index; if (_indexes.TryGetValue(path, out index)) return index.Match(operation, value); return Key.EmptyKeys; }
public void Comparison_Floats( float a, CompareOperation operation, float b, float precision, TestExceptionType eType) { this.RunTest(() => this.Checker.Comparison(a, operation, b, precision), eType); }
public void Comparison_Doubles( double a, CompareOperation operation, double b, double precision, TestExceptionType eType) { this.RunTest(() => this.Checker.Comparison(a, operation, b, precision), eType); }
public bool Comparison( double a, CompareOperation operation, double b, double precision, string message, params object[] args) { return(true); }
public bool Comparison( float a, CompareOperation operation, float b, float precision, string message, params object[] args) { return(true); }
/// <summary> /// Show a message if the specified values do not compare in the specified way. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="a">The first value to compare.</param> /// <param name="operation">The <see cref="CompareOperation" /> to perform.</param> /// <param name="b">The second value to compare.</param> /// <param name="message">The message to show.</param> /// <param name="args">The arguments to the message to display.</param> /// <returns> /// True only if the assert condition passed. Otherwise false. /// </returns> public bool Comparison <T>(T a, CompareOperation operation, T b, string message, params object[] args) where T : IComparable { return(this.Check( AssertType.Compare, operation.Compare(a, b), message, args, "Compare check failed. [{0} {1} {2}]", a, operation.GetOperation(), b)); }
private bool CompareText(ResourceText target, ResourceText op1, CompareOperation operation) { switch (operation) { case CompareOperation.Equals: return(target.Value == op1.Value); default: GameManager.DebugLog("Error - operator invalid"); break; } return(false); }
public override string ToEncodedString() { const string filterPattern = @"{{""type"":""DependentColumnFilter"",""op"":""{0}"",""family"":""{1}"",""qualifier"":""{2}"",""dropDependentColumn"":{3},""comparator"":{{{4}}}}}"; return(string.Format( CultureInfo.InvariantCulture, filterPattern, CompareOperation.ToCodeName(), Convert.ToBase64String(Family), Convert.ToBase64String(Qualifier), DropDependentColumn.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), Comparator.ToEncodedString())); }
public override string ToEncodedString() { const string filterPattern = @"{{""type"":""SingleColumnValueFilter"",""op"":""{0}"",""family"":""{1}"",""qualifier"":""{2}"",""ifMissing"":{3},""latestVersion"":{4},""comparator"":{{{5}}}}}"; return(string.Format( CultureInfo.InvariantCulture, filterPattern, CompareOperation.ToCodeName(), Convert.ToBase64String(Family), Convert.ToBase64String(Qualifier), FilterIfMissing.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), LatestVersion.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), Comparator.ToEncodedString())); }
public static bool CompareTo(this object @this, CompareOperation operation, object obj) { switch (operation) { case CompareOperation.GreaterThan: return(@this.CompareTo(obj) > 0); case CompareOperation.GreaterThanOrEquals: return(@this.CompareTo(obj) >= 0); case CompareOperation.LessThan: return(@this.CompareTo(obj) < 0); case CompareOperation.LessThanOrEquals: return(@this.CompareTo(obj) <= 0); case CompareOperation.Contains: return(@this.IsContains(obj)); case CompareOperation.NotContains: return([email protected](obj)); case CompareOperation.StartsWith: return(@this.IsStartsWith(obj)); case CompareOperation.EndsWith: return(@this.IsEndsWith(obj)); case CompareOperation.In: return(@this.IsIn(obj)); case CompareOperation.NotIn: return([email protected](obj)); case CompareOperation.IsNull: return(@this == null && obj == null); case CompareOperation.NotNull: return(@this != null || obj != null); case CompareOperation.NotEquals: return(@this.IsNotEquals(obj)); default: case CompareOperation.Equals: return(@this.IsEquals(obj)); } }
/// <summary> /// Show a message if the specified values do not compare in the specified way. /// </summary> /// <param name="a">The first value to compare.</param> /// <param name="operation">The <see cref="CompareOperation" /> to perform.</param> /// <param name="b">The second value to compare.</param> /// <param name="precision">The acceptable difference when comparing the floating point value.</param> /// <param name="message">The message to show.</param> /// <param name="args">The arguments to the message to display.</param> /// <returns> /// True only if the assert condition passed. Otherwise false. /// </returns> public bool Comparison( double a, CompareOperation operation, double b, double precision, string message, params object[] args) { return(this.Check( AssertType.Compare, operation.Compare(a, b, precision), message, args, "Compare check failed. [{0} {1} {2}]", a, operation.GetOperation(), b)); }
private string GetFilterPattern(CompareOperation operation) { switch (operation) { case CompareOperation.Contains: case CompareOperation.NotContains: return(ContainsPattern); case CompareOperation.StartsWith: return(StartsWithPattern); case CompareOperation.EndsWith: return(EndsWithPattern); default: return(string.Empty); } }
public static CompareOperation ParseOperation(XElement element) { var result = new CompareOperation(); result.OperationType = element.Name.LocalName; result.FieldName = (from product in element.Elements("FieldRef") select product.Attribute("Name").Value ).FirstOrDefault(); result.ValueType = (from product in element.Elements("Value") select product.Attribute("Type").Value ).FirstOrDefault(); result.Value = (from product in element.Elements("Value") select product.Value ).FirstOrDefault(); return(result); }
protected virtual string GetOperator(CompareOperation operation) { switch (operation) { case CompareOperation.NotEquals: return(" <> "); case CompareOperation.GreaterThanOrEquals: return(" >= "); case CompareOperation.GreaterThan: return(" > "); case CompareOperation.LessThanOrEquals: return(" <= "); case CompareOperation.LessThan: return(" < "); case CompareOperation.In: return(" IN "); case CompareOperation.NotIn: return(" NOT IN "); case CompareOperation.Contains: case CompareOperation.StartsWith: case CompareOperation.EndsWith: return(" LIKE "); case CompareOperation.NotContains: return(" NOT LIKE "); case CompareOperation.IsNull: return(" IS NULL "); case CompareOperation.NotNull: return(" IS NOT NULL "); default: return(" = "); } }
private bool CompareNumber(ResourceNumber target, ResourceNumber op1, CompareOperation operation) { //GameManager.DebugLog("Comparing: " + target.Value + " " + operation + " " + op1.Value); //GameManager.DebugLog((target.Value >= op1.Value).ToString()); switch (operation) { case CompareOperation.Equals: return(target.Value == op1.Value); case CompareOperation.Larger: return(target.Value > op1.Value); case CompareOperation.LargerOrEqual: return(target.Value >= op1.Value); case CompareOperation.Smaller: return(target.Value < op1.Value); case CompareOperation.SmallerOrEqual: return(target.Value <= op1.Value); } return(false); }
public void SetConditionOperation(Guid id, string value) { CompareOperation exp; if (CompareOperation.TryParse(value, out exp)) { if (Context == null || Context.Def == null || Context.Def.Conditions == null) { return; } var condition = FindConditionDef(Context.Def, id) as ReportConditionDef; if (condition == null) { return; } condition.Condition = exp; } }
public void Compare(PropertyPath path, CompareOperation compareOperation, object value) { _expressions.Push(new CompareIndexExpression(path, compareOperation, value)); }
private bool TryBinaryAnalyzeCompare(CompareOperation operation, Expression right) { if (_propertyPath == null) return false; var path = _propertyPath; var pathString = _propertyPath.GetUniqueName(); _propertyPath = null; if (_entityMap == null) return false; if (operation == CompareOperation.Equal && string.Equals(pathString, _entityMap.KeyName, StringComparison.InvariantCulture)) { _executor.EqualKey(((ConstantExpression) right).Value); return true; } var index = _entityMap.Indexes.FirstOrDefault(i => string.Equals(i.UniqueName, pathString, StringComparison.InvariantCulture)); if (index == null) return false; _executor.Compare(path, operation, ((ConstantExpression)right).Value); return true; }
public override void Reset() { base.Reset(); storeValue = 0f; compareOperation = CompareOperation.None; compareToValue = 0f; compareAbsValues = false; isTrueEvent = null; isFalseEvent = null; valueChangedEvent = null; }
public CompareIndexExpression(PropertyPath path, CompareOperation compareOperation, object value) { _path = path; _compareOperation = compareOperation; _value = value; }