public static MakeComparisonError ( RubyContext context, object self, object other ) : |
||
context | RubyContext | |
self | object | |
other | object | |
return |
// Standard Ruby way of calling "<=>" // Call it, and then see if the result is > 0 by calling ">" // If not, see if the result is < 0 by calling "<" // Returns -1, 0, 1 with the usual interpretation public static int Compare(RubyContext /*!*/ context, object lhs, object rhs) { object result = _CompareSharedSite.Target(_CompareSharedSite, context, lhs, rhs); if (result == null) { throw RubyExceptions.MakeComparisonError(context, lhs, rhs); } return(ConvertCompareResult(context, result)); }
/// <summary> /// Applies given operator on coerced values and converts its result to Ruby truth (using Protocols.IsTrue). /// </summary> /// <exception cref="ArgumentError"> /// "coerce" method is not defined, throws a subclass of SystemException, or returns something other than a pair of objects. /// </exception> public static bool CoerceAndRelate(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage, string /*!*/ relationalOp, object self, object other) { object result; if (TryCoerceAndApply(coercionStorage, comparisonStorage, relationalOp, self, other, out result)) { return(RubyOps.IsTrue(result)); } throw RubyExceptions.MakeComparisonError(coercionStorage.Context, self, other); }
/// <summary> /// Compare the values of self and other (coerce using other as the object then call the passed in comparison operator). /// </summary> /// <remarks> /// This method is used for <, <=, > and >= operators. If we can't coerce then throw a specific comparison exception. /// </remarks> /// <exception cref="ArgumentException">If self and other cannot be coerced to the same type.</exception> public static bool CoerceAndCallRelationOperator(RubyContext /*!*/ context, object self, object other, DynamicInvocation invoke) { try { // Swap self and other around to do the coercion. RubyArray coercedValues = RubySites.Coerce(context, other, self); return(RubyOps.IsTrue(invoke(context, coercedValues[0], coercedValues[1]))); } catch (MemberAccessException x) { throw RubyExceptions.MakeComparisonError(context, self, other, x); } catch (ArgumentException x) { throw RubyExceptions.MakeComparisonError(context, self, other, x); } catch (NullReferenceException x) { throw RubyExceptions.MakeComparisonError(context, self, other, x); } }
/// <summary> /// Try to compare the lhs and rhs. Throws and exception if comparison returns null. Returns -1/0/+1 otherwise. /// </summary> public static int Compare(ComparisonStorage /*!*/ comparisonStorage, object lhs, object rhs) { var compare = comparisonStorage.CompareSite; var result = compare.Target(compare, lhs, rhs); if (result != null) { return(Protocols.ConvertCompareResult(comparisonStorage, result)); } else { throw RubyExceptions.MakeComparisonError(comparisonStorage.Context, lhs, rhs); } }
/// <summary> /// Try to compare the lhs and rhs. Throws and exception if comparison returns null. Returns -1/0/+1 otherwise. /// </summary> public static int Compare( BinaryOpStorage /*!*/ comparisonStorage, BinaryOpStorage /*!*/ lessThanStorage, BinaryOpStorage /*!*/ greaterThanStorage, object lhs, object rhs) { var compare = comparisonStorage.GetCallSite("<=>"); var result = compare.Target(compare, lhs, rhs); if (result != null) { return(Protocols.ConvertCompareResult(lessThanStorage, greaterThanStorage, result)); } else { throw RubyExceptions.MakeComparisonError(comparisonStorage.Context, lhs, rhs); } }