/// <summary> /// Returns a value for the logical "less than" operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns>Node's value.</returns> protected override object Get(object context, EvaluationContext evalContext) { var lhs = GetLeftValue(context, evalContext); var rhs = GetRightValue(context, evalContext); return(CompareUtils.Compare(lhs, rhs) < 0); }
protected override object Evaluate(object context, BaseNode.EvaluationContext evalContext) { object first = base.Left.EvaluateInternal(context, evalContext); object obj3 = base.Right.EvaluateInternal(context, evalContext); if (first == null) { return(obj3 == null); } if (obj3 == null) { return(false); } if (first.GetType() == obj3.GetType()) { return(first.Equals(obj3)); } if (first.GetType().IsEnum&& (obj3 is string)) { return(first.Equals(Enum.Parse(first.GetType(), (string)obj3))); } if (obj3.GetType().IsEnum&& (first is string)) { return(obj3.Equals(Enum.Parse(obj3.GetType(), (string)first))); } return(CompareUtils.Compare(first, obj3) == 0); }
/// <summary> /// Returns a value for the logical inequality operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns>Node's value.</returns> protected override object Get(object context, EvaluationContext evalContext) { object leftVal = GetLeftValue(context, evalContext); object rightVal = GetRightValue(context, evalContext); if (leftVal == null) { return(rightVal != null); } else if (rightVal == null) { return(true); } else if (leftVal.GetType() == rightVal.GetType()) { if (leftVal is Array) { return(!ArrayUtils.AreEqual(leftVal as Array, rightVal as Array)); } else { return(!leftVal.Equals(rightVal)); } } else { return(CompareUtils.Compare(leftVal, rightVal) != 0); } }
protected override object Evaluate(object context, EvaluationContext evalContext) { object left = Left.EvaluateInternal(context, evalContext); object right = Right.EvaluateInternal(context, evalContext); if (left == null) { return(right == null); } else if (right == null) { return(false); } else if (left.GetType() == right.GetType()) { return(left.Equals(right)); } else if (left.GetType().IsEnum&& right is string) { return(left.Equals(Enum.Parse(left.GetType(), (string)right))); } else if (right.GetType().IsEnum&& left is string) { return(right.Equals(Enum.Parse(right.GetType(), (string)left))); } else { return(CompareUtils.Compare(left, right) == 0); } }
protected override object Evaluate(object context, BaseNode.EvaluationContext evalContext) { object first = base.Left.EvaluateInternal(context, evalContext); object second = base.Right.EvaluateInternal(context, evalContext); return(CompareUtils.Compare(first, second) <= 0); }
/// <summary> /// Returns a value for the logical equality operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns>Node's value.</returns> protected override object Get(object context, EvaluationContext evalContext) { var lhs = GetLeftValue(context, evalContext); var rhs = GetRightValue(context, evalContext); if (lhs == null) { return(rhs == null); } if (rhs == null) { return(false); } if (lhs.GetType() == rhs.GetType()) { if (lhs is Array) { return(ArrayUtils.AreEqual(lhs as Array, rhs as Array)); } return(lhs.Equals(rhs)); } if (lhs.GetType().IsEnum&& rhs is string) { return(lhs.Equals(Enum.Parse(lhs.GetType(), (string)rhs))); } if (rhs.GetType().IsEnum&& lhs is string) { return(rhs.Equals(Enum.Parse(rhs.GetType(), (string)lhs))); } return(CompareUtils.Compare(lhs, rhs) == 0); }
/// <summary> /// Returns a value for the logical "greater than or equal" operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns>Node's value.</returns> protected override object Get(object context, EvaluationContext evalContext) { object left = GetLeftValue(context, evalContext); object right = GetRightValue(context, evalContext); return(CompareUtils.Compare(left, right) >= 0); }
protected override object Evaluate(object context, EvaluationContext evalContext) { object left = Left.EvaluateInternal(context, evalContext); object right = Right.EvaluateInternal(context, evalContext); return(CompareUtils.Compare(left, right) > 0); }
public bool GreaterThan(ref Indexed <T> x, ref Indexed <T> y) { int c = CompareUtils.Compare(ref x.Value, ref y.Value); bool result = c > 0; if (c == 0) { result = x.Index > y.Index; } return(result); }
public bool LessThan(ref Indexed <T> x, ref Indexed <T> y) { int c = CompareUtils.Compare(ref x.Value, ref y.Value); bool result = c < 0; if (c == 0) { result = x.Index < y.Index; } return(result); }
/// <summary> /// Returns the smallest item in the source collection. /// </summary> /// <param name="source"> /// The source collection to process. /// </param> /// <param name="args"> /// Ignored. /// </param> /// <returns> /// The smallest item in the source collection. /// </returns> public object Process(ICollection source, object[] args) { object minItem = null; foreach (object item in source) { if ((minItem == null && item != null) || (CompareUtils.Compare(minItem, item) > 0)) { minItem = item; } } return(minItem); }
/// <summary> /// Returns the largest item in the source collection. /// </summary> /// <param name="source"> /// The source collection to process. /// </param> /// <param name="args"> /// Ignored. /// </param> /// <returns> /// The largest item in the source collection. /// </returns> public object Process(ICollection source, object[] args) { object maxItem = null; foreach (object item in source) { if (CompareUtils.Compare(maxItem, item) < 0) { maxItem = item; } } return(maxItem); }
protected override object Evaluate(object context, BaseNode.EvaluationContext evalContext) { object first = base.Left.EvaluateInternal(context, evalContext); IList list = base.Right.EvaluateInternal(context, evalContext) as IList; if ((list == null) || (list.Count != 2)) { throw new ArgumentException("Right operand for the 'between' operator has to be a two-element list."); } object second = list[0]; object obj4 = list[1]; return((CompareUtils.Compare(first, second) < 0) ? ((object)0) : ((object)(CompareUtils.Compare(first, obj4) <= 0))); }
public int CompareTo(object obj) { if (obj is SubscriptionInfo) { SubscriptionInfo other = (SubscriptionInfo)obj; //return (string.Equals(other.Selector, _selector) && string.Equals(other.Subtopic, _subtopic)) ? 0 : -1; int result = CompareUtils.Compare(other.Selector, _selector) * -1; if (result == 0) { result = CompareUtils.Compare(other.Subtopic, _subtopic); } return(result); } return(-1); }
/// <summary> /// Returns a value for the logical IN operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns> /// true if the left operand is contained within the right operand, false otherwise. /// </returns> protected override object Get(object context, EvaluationContext evalContext) { object value = GetLeftValue(context, evalContext); IList range = GetRightValue(context, evalContext) as IList; if (range == null || range.Count != 2) { throw new ArgumentException("Right operand for the 'between' operator has to be a two-element list."); } object low = range[0]; object high = range[1]; return(CompareUtils.Compare(value, low) >= 0 && CompareUtils.Compare(value, high) <= 0); }
protected override object Evaluate(object context, BaseNode.EvaluationContext evalContext) { object first = base.Left.EvaluateInternal(context, evalContext); object obj3 = base.Right.EvaluateInternal(context, evalContext); if (first == null) { return(obj3 != null); } if (obj3 == null) { return(true); } if (first.GetType() == obj3.GetType()) { return(!first.Equals(obj3)); } return(CompareUtils.Compare(first, obj3) != 0); }
protected override object Evaluate(object context, EvaluationContext evalContext) { object left = Left.EvaluateInternal(context, evalContext); object right = Right.EvaluateInternal(context, evalContext); if (left == null) { return(right != null); } else if (right == null) { return(true); } else if (left.GetType() == right.GetType()) { return(!left.Equals(right)); } else { return(CompareUtils.Compare(left, right) != 0); } }
private static int Compare(ref Indexed <T?> x, ref Indexed <T?> y) { int c; if (x.Value is T xValue) { c = 1; if (y.Value is T yValue) { c = CompareUtils.Compare(ref xValue, ref yValue); } } else { c = 0; if (y.Value is not null) { c = -1; } } return(c); }
/// <summary> /// Returns a value for the logical equality operator node. /// </summary> /// <param name="context">Context to evaluate expressions against.</param> /// <param name="evalContext">Current expression evaluation context.</param> /// <returns>Node's value.</returns> protected override object Get(object context, EvaluationContext evalContext) { object left = GetLeftValue(context, evalContext); object right = GetRightValue(context, evalContext); if (left == null) { return(right == null); } else if (right == null) { return(false); } else if (left.GetType() == right.GetType()) { if (left is Array) { return(ArrayUtils.AreEqual(left as Array, right as Array)); } else { return(left.Equals(right)); } } else if (left.GetType().IsEnum&& right is string) { return(left.Equals(Enum.Parse(left.GetType(), (string)right))); } else if (right.GetType().IsEnum&& left is string) { return(right.Equals(Enum.Parse(right.GetType(), (string)left))); } else { return(CompareUtils.Compare(left, right) == 0); } }