public void Initialize(BinaryOpStorage/*!*/ comparisonStorage,
RubyContext/*!*/ context, object begin, object end, bool excludeEnd) {
if (_initialized) {
throw RubyExceptions.CreateNameError("`initialize' called twice");
}
// Range tests whether the items can be compared, and uses that to determine if the range is valid
// Only a non-existent <=> method or a result of nil seems to trigger the exception.
object compareResult;
var site = comparisonStorage.GetCallSite("<=>");
try {
compareResult = site.Target(site, begin, end);
} catch (Exception) {
compareResult = null;
}
if (compareResult == null) {
throw RubyExceptions.CreateArgumentError("bad value for range");
}
_begin = begin;
_end = end;
_excludeEnd = excludeEnd;
_initialized = true;
}
public static void Abort(BinaryOpStorage/*!*/ writeStorage, object/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ message)
{
var site = writeStorage.GetCallSite("write", 1);
site.Target(site, writeStorage.Context.StandardErrorOutput, message);
Exit(self, 1);
}
public static void Print(BinaryOpStorage/*!*/ writeStorage, object self, object value) {
Protocols.Write(writeStorage, self, value ?? MutableString.CreateAscii("nil"));
MutableString delimiter = writeStorage.Context.OutputSeparator;
if (delimiter != null) {
Protocols.Write(writeStorage, self, delimiter);
}
}
public static void PrintFormatted(
StringFormatterSiteStorage/*!*/ storage,
ConversionStorage<MutableString>/*!*/ stringCast,
BinaryOpStorage/*!*/ writeStorage,
object/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ format, params object[]/*!*/ args)
{
KernelOps.PrintFormatted(storage, stringCast, writeStorage, null, self, format, args);
}
public static bool Greater(
BinaryOpStorage/*!*/ compareStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
object self, object other) {
return Compare(compareStorage, lessThanStorage, greaterThanStorage, self, other).GetValueOrDefault(0) > 0;
}
public static bool Equal(BinaryOpStorage/*!*/ equals, decimal self, object other) {
if (other is decimal) {
return self == (decimal)other;
}
// Call == on the right operand like Float#== does
return Protocols.IsEqual(equals, other, self);
}
public static bool Between(
BinaryOpStorage/*!*/ compareStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
object self, object min, object max) {
return !Less(compareStorage, lessThanStorage, greaterThanStorage, self, min)
&& !Greater(compareStorage, lessThanStorage, greaterThanStorage, self, max);
}
public static RubyArray/*!*/ ToYamlProperties(
BinaryOpStorage/*!*/ comparisonStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
RubyContext/*!*/ context, object self) {
return ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, context,
null, KernelOps.InstanceVariables(context, self)
);
}
public static object Abs(BinaryOpStorage/*!*/ lessThanStorage, UnaryOpStorage/*!*/ minusStorage, object self)
{
var lessThan = lessThanStorage.GetCallSite("<");
if (RubyOps.IsTrue(lessThan.Target(lessThan, self, 0))) {
var minus = minusStorage.GetCallSite("-@");
return minus.Target(minus, self);
}
return self;
}
public static Object Scan(ConversionStorage<MutableString>/*!*/ toMutableStringStorage, RespondToStorage/*!*/ respondsTo,
BinaryOpStorage/*!*/ readIOStorage, BlockParam block, RubyModule/*!*/ self, Object/*!*/ source, Hash/*!*/ options)
{
Object elementContent;
if (!self.TryGetConstant(null, "ElementContent", out elementContent) && !(elementContent is Hash)) {
throw new Exception("Hpricot::ElementContent is missing or it is not an Hash");
}
var scanner = new HpricotScanner(toMutableStringStorage, readIOStorage, block);
return scanner.Scan(source, options, elementContent as Hash);
}
public static MutableString/*!*/ Putc(BinaryOpStorage/*!*/ writeStorage, object self, [NotNull]MutableString/*!*/ val) {
if (val.IsEmpty) {
throw RubyExceptions.CreateTypeError("can't convert String into Integer");
}
// writes a single byte into the output stream:
var c = MutableString.CreateBinary(val.GetBinarySlice(0, 1));
Protocols.Write(writeStorage, self, c);
return val;
}
public static object DefineFinalizer(RespondToStorage/*!*/ respondTo, BinaryOpStorage/*!*/ call, RubyModule/*!*/ self, object obj, object finalizer)
{
if (!Protocols.RespondTo(respondTo, finalizer, "call")) {
throw RubyExceptions.CreateArgumentError("finalizer should be callable (respond to :call)");
}
respondTo.Context.SetInstanceVariable(obj, FinalizerInvoker.InstanceVariableName, new FinalizerInvoker(call.GetCallSite("call"), finalizer));
RubyArray result = new RubyArray(2);
result.Add(0);
result.Add(finalizer);
return result;
}
/// <summary>
/// Try to compare the lhs and rhs. Throws and exception if comparison returns null. Returns null on failure, -1/0/+1 otherwise.
/// </summary>
private static int? Compare(BinaryOpStorage/*!*/ compareStorage, BinaryOpStorage/*!*/ lessThanStorage, BinaryOpStorage/*!*/ greaterThanStorage,
object lhs, object rhs) {
// calls method_missing, doesn't catch any exception:
var compare = compareStorage.GetCallSite("<=>");
object compareResult = compare.Target(compare, lhs, rhs);
if (compareResult != null) {
return Protocols.ConvertCompareResult(lessThanStorage, greaterThanStorage, compareResult);
} else {
throw RubyExceptions.MakeComparisonError(lessThanStorage.Context, lhs, rhs);
}
}
public static object Contains(CallSiteStorage<EachSite>/*!*/ each, BinaryOpStorage/*!*/ equals, object self, object value)
{
object result = ScriptingRuntimeHelpers.BooleanToObject(false);
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
if (Protocols.IsEqual(equals, item, value)) {
result = ScriptingRuntimeHelpers.BooleanToObject(true);
return selfBlock.Break(result);
}
return null;
}));
return result;
}
public static int Count(CallSiteStorage<EachSite>/*!*/ each, BinaryOpStorage/*!*/ equals, BlockParam comparer, object self, object value)
{
if (comparer != null) {
each.Context.ReportWarning("given block not used");
}
int result = 0;
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
if (Protocols.IsEqual(equals, item, value)) {
result++;
}
return null;
}));
return result;
}
public static bool Equal(BinaryOpStorage/*!*/ compareStorage, object self, object other)
{
if (self == other) {
return true;
}
// calls method_missing:
var compare = compareStorage.GetCallSite("<=>");
object compareResult;
try {
compareResult = compare.Target(compare, self, other);
} catch (SystemException) {
// catches StandardError (like rescue)
return false;
}
return compareResult is int && (int)compareResult == 0;
}
public static object GreaterThanOrEqual(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage,
BigDecimal /*!*/ self, object other)
{
return(Protocols.TryCoerceAndApply(coercionStorage, comparisonStorage, ">=", self, other));
}
public static object /*!*/ Output(BinaryOpStorage /*!*/ writeStorage, object self, object value)
{
Protocols.Write(writeStorage, self, value);
return(self);
}
public static object Quotient(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite,
BigDecimal /*!*/ self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "quo", self, other));
}
public static bool LessThan(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage, double self, object other)
{
return(Protocols.CoerceAndRelate(coercionStorage, comparisonStorage, "<", self, other));
}
// Convience function for constructing from C#, calls initialize
public Range(BinaryOpStorage /*!*/ comparisonStorage,
RubyContext /*!*/ context, object begin, object end, bool excludeEnd)
{
Initialize(comparisonStorage, context, begin, end, excludeEnd);
}
public static object Remainder(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, object /*!*/ self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "remainder", self, other));
}
public static RubyArray Grep(CallSiteStorage<EachSite>/*!*/ each, BinaryOpStorage/*!*/ caseEquals,
BlockParam action, object self, object pattern) {
RubyArray result = new RubyArray();
var site = caseEquals.GetCallSite("===");
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
if (RubyOps.IsTrue(site.Target(site, pattern, item))) {
if (action != null) {
if (action.Yield(item, out item)) {
return item;
}
}
result.Add(item);
}
return null;
}));
return result;
}
public static object Power(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, object /*!*/ self, object exponent)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "**", self, exponent));
}
public static object Modulo(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, object /*!*/ self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "modulo", self, other));
}
public static bool Equal(
UnaryOpStorage /*!*/ messageStorage, UnaryOpStorage /*!*/ backtraceStorage, BinaryOpStorage /*!*/ stringEqlStorage,
BinaryOpStorage /*!*/ arrayEqlStorage, RespondToStorage /*!*/ respondTo, Exception /*!*/ self, object /*!*/ other)
{
if (!Protocols.RespondTo(respondTo, other, "message") || !Protocols.RespondTo(respondTo, other, "backtrace"))
{
return(false);
}
var messageSite = messageStorage.GetCallSite("message");
var selfMessage = messageSite.Target(messageSite, self);
var otherMessage = messageSite.Target(messageSite, other);
var backtraceSite = backtraceStorage.GetCallSite("backtrace");
var selfBacktrace = backtraceSite.Target(backtraceSite, self) as System.Collections.IList;
var otherBacktrace = backtraceSite.Target(backtraceSite, other);
var stringEqlSite = stringEqlStorage.GetCallSite("==");
return(true.Equals(stringEqlSite.Target(stringEqlSite, selfMessage, otherMessage)) &&
RubyArray.Equals(arrayEqlStorage, selfBacktrace, otherBacktrace));
}
public static object Add(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ opStorage,
BigDecimal /*!*/ self, object other, [DefaultProtocol] int n)
{
return(Protocols.CoerceAndApply(coercionStorage, opStorage, "+", self, other));
}
public static object LessThan(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage,
BigDecimal /*!*/ self, object other)
{
return(Protocols.TryCoerceAndApply(coercionStorage, comparisonStorage, "<", self, other));
}
public static bool Equals(RespondToStorage/*!*/ respondToStorage, BinaryOpStorage/*!*/ equalsStorage, string/*!*/ self, object other) {
return MutableStringOps.Equals(respondToStorage, equalsStorage, self, other);
}
public static bool Equal(BinaryOpStorage /*!*/ equals, BigInteger /*!*/ self, object other)
{
// If we can't convert then swap self and other and try again.
return(Protocols.IsEqual(equals, other, self));
}
public static int SysWrite(BinaryOpStorage/*!*/ writeStorage, ConversionStorage<MutableString>/*!*/ tosConversion,
RubyContext/*!*/ context, RubyIO/*!*/ self, [NotNull]MutableString/*!*/ val) {
RubyBufferedStream stream = self.GetWritableStream();
if (stream.DataBuffered) {
PrintOps.ReportWarning(writeStorage, tosConversion, MutableString.CreateAscii("syswrite for buffered IO"));
}
int bytes = Write(self, val);
self.Flush();
return bytes;
}
public static void RaiseException(RespondToStorage /*!*/ respondToStorage, UnaryOpStorage /*!*/ storage0, BinaryOpStorage /*!*/ storage1,
CallSiteStorage <Action <CallSite, Exception, RubyArray> > /*!*/ setBackTraceStorage,
Thread /*!*/ self, object /*!*/ obj, [Optional] object arg, [Optional] RubyArray backtrace)
{
if (self == Thread.CurrentThread)
{
KernelOps.RaiseException(respondToStorage, storage0, storage1, setBackTraceStorage, self, obj, arg, backtrace);
return;
}
#if FEATURE_EXCEPTION_STATE
Exception e = KernelOps.CreateExceptionToRaise(respondToStorage, storage0, storage1, setBackTraceStorage, obj, arg, backtrace);
RaiseAsyncException(self, e);
#else
throw new NotImplementedError("Thread#raise not supported on this platform");
#endif
}
public static object Multiply(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite,
BigDecimal /*!*/ self, object other, [DefaultProtocol] int n)
{
// TODO: converts result to BigDecimal
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "mult", self, other));
}
public static Range /*!*/ CreateRange(BinaryOpStorage /*!*/ comparisonStorage,
RubyClass /*!*/ self, object begin, object end, [Optional] bool excludeEnd)
{
return(new Range(comparisonStorage, self.Context, begin, end, excludeEnd));
}
public static bool GreaterThanOrEqual(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage, double self, object other)
{
return(Protocols.CoerceAndRelate(coercionStorage, comparisonStorage, ">=", self, other));
}
public static Range /*!*/ Reinitialize(BinaryOpStorage /*!*/ comparisonStorage,
RubyContext /*!*/ context, Range /*!*/ self, object begin, object end, [Optional] bool excludeEnd)
{
self.Initialize(comparisonStorage, context, begin, end, excludeEnd);
return(self);
}
public static void PutsEmptyLine(BinaryOpStorage /*!*/ writeStorage, object self)
{
Protocols.Write(writeStorage, self, MutableString.CreateAscii("\n"));
}
public static object Modulo(BinaryOpStorage /*!*/ moduloStorage, RubyContext /*!*/ context, BigDecimal /*!*/ self, double other)
{
var modulo = moduloStorage.GetCallSite("modulo");
return(modulo.Target(modulo, BigDecimal.ToFloat(GetConfig(context), self), other));
}
public static object Times(BinaryOpStorage /*!*/ lessThanStorage, BinaryOpStorage /*!*/ addStorage, BlockParam block, object /*!*/ self)
{
return((block != null) ? TimesImpl(lessThanStorage, addStorage, block, self) :
new Enumerator((_, innerBlock) => TimesImpl(lessThanStorage, addStorage, innerBlock, self)));
}
/// <summary>
/// Applies given operator on coerced values and returns the result.
/// </summary>
/// <exception cref="TypeError">
/// "coerce" method is not defined, throws a subclass of SystemException, or returns something other than a pair of objects.
/// </exception>
public static object CoerceAndApply(BinaryOpStorage/*!*/ coercionStorage, BinaryOpStorage/*!*/ binaryOpStorage,
string/*!*/ binaryOp, object self, object other) {
object result;
if (TryCoerceAndApply(coercionStorage, binaryOpStorage, binaryOp, self, other, out result)) {
return result;
}
throw RubyExceptions.MakeCoercionError(coercionStorage.Context, other, self);
}
public static object Pred(BinaryOpStorage /*!*/ subStorage, object /*!*/ self)
{
var site = subStorage.GetCallSite("-");
return(site.Target(site, self, ClrInteger.One));
}
private static bool TryCoerceAndApply(
BinaryOpStorage/*!*/ coercionStorage,
BinaryOpStorage/*!*/ binaryOpStorage, string/*!*/ binaryOp,
object self, object other, out object result) {
var coerce = coercionStorage.GetCallSite("coerce", new RubyCallSignature(1, RubyCallFlags.HasImplicitSelf));
IList coercedValues;
try {
// Swap self and other around to do the coercion.
coercedValues = coerce.Target(coerce, other, self) as IList;
} catch (SystemException) {
// catches StandardError (like rescue)
result = null;
return false;
}
if (coercedValues != null && coercedValues.Count == 2) {
var opSite = binaryOpStorage.GetCallSite(binaryOp);
result = opSite.Target(opSite, coercedValues[0], coercedValues[1]);
return true;
}
result = null;
return false;
}
public static object DownTo(BinaryOpStorage /*!*/ lessThanStorage, BinaryOpStorage /*!*/ subtractStorage,
BlockParam block, object /*!*/ self, object other)
{
return((block != null) ? DownToImpl(lessThanStorage, subtractStorage, block, self, other) :
new Enumerator((_, innerBlock) => DownToImpl(lessThanStorage, subtractStorage, innerBlock, self, other)));
}
public static object DivMod(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite,
RubyContext /*!*/ context, BigDecimal /*!*/ self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "divmod", self, other));
}
public static object GetMinimum(
CallSiteStorage<EachSite>/*!*/ each,
BinaryOpStorage/*!*/ compareStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
BlockParam comparer, object self) {
return GetExtreme(each, compareStorage, lessThanStorage, greaterThanStorage, comparer, self, 1/*look for min*/);
}
public static object Sort(
CallSiteStorage<EachSite>/*!*/ each,
BinaryOpStorage/*!*/ comparisonStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
BlockParam keySelector, object self) {
return ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, keySelector, ToArray(each, self));
}
/// <summary>
/// Applies given operator on coerced values and returns the result.
/// </summary>
/// <exception cref="TypeError">
/// "coerce" method is not defined, throws a subclass of SystemException, or returns something other than a pair of objects.
/// </exception>
public static object TryCoerceAndApply(
BinaryOpStorage/*!*/ coercionStorage,
BinaryOpStorage/*!*/ binaryOpStorage, string/*!*/ binaryOp,
object self, object other) {
if (other == null) {
return null;
}
object result;
if (TryCoerceAndApply(coercionStorage, binaryOpStorage, binaryOp, self, other, out result)) {
if (result != null) {
return RubyOps.IsTrue(result);
}
}
return null;
}
public static object UpTo(BinaryOpStorage /*!*/ greaterThanStorage, BinaryOpStorage /*!*/ addStorage,
BlockParam block, object /*!*/ self, object other)
{
return((block != null) ? UpToImpl(greaterThanStorage, addStorage, block, self, other) :
new Enumerator((_, innerBlock) => UpToImpl(greaterThanStorage, addStorage, innerBlock, self, other)));
}
public static object Compare(BinaryOpStorage/*!*/ comparisonStorage, RespondToStorage/*!*/ respondToStorage, string/*!*/ self, object other) {
return MutableStringOps.Compare(comparisonStorage, respondToStorage, self, other);
}
public static object DivMod(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, double self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "divmod", self, other));
}
public static object CopyStream(
ConversionStorage<MutableString>/*!*/ toPath, ConversionStorage<int>/*!*/ toInt, RespondToStorage/*!*/ respondTo,
BinaryOpStorage/*!*/ writeStorage, CallSiteStorage<Func<CallSite, object, object, object, object>>/*!*/ readStorage,
RubyClass/*!*/ self, object src, object dst, [DefaultParameterValue(-1)]int count, [DefaultParameterValue(-1)]int src_offset) {
if (count < -1) {
throw RubyExceptions.CreateArgumentError("count should be >= -1");
}
if (src_offset < -1) {
throw RubyExceptions.CreateArgumentError("src_offset should be >= -1");
}
RubyIO srcIO = src as RubyIO;
RubyIO dstIO = dst as RubyIO;
Stream srcStream = null, dstStream = null;
var context = toPath.Context;
CallSite<Func<CallSite, object, object, object>> writeSite = null;
CallSite<Func<CallSite, object, object, object, object>> readSite = null;
try {
if (srcIO == null || dstIO == null) {
var toPathSite = toPath.GetSite(TryConvertToPathAction.Make(toPath.Context));
var srcPath = toPathSite.Target(toPathSite, src);
if (srcPath != null) {
srcStream = new FileStream(context.DecodePath(srcPath), FileMode.Open, FileAccess.Read);
} else {
readSite = readStorage.GetCallSite("read", 2);
}
var dstPath = toPathSite.Target(toPathSite, dst);
if (dstPath != null) {
dstStream = new FileStream(context.DecodePath(dstPath), FileMode.Truncate);
} else {
writeSite = writeStorage.GetCallSite("write", 1);
}
} else {
srcStream = srcIO.GetReadableStream();
dstStream = dstIO.GetWritableStream();
}
if (src_offset != -1) {
if (srcStream == null) {
throw RubyExceptions.CreateArgumentError("cannot specify src_offset for non-IO");
}
srcStream.Seek(src_offset, SeekOrigin.Current);
}
MutableString userBuffer = null;
byte[] buffer = null;
long bytesCopied = 0;
long remaining = (count < 0) ? Int64.MaxValue : count;
int minBufferSize = 16 * 1024;
if (srcStream != null) {
buffer = new byte[Math.Min(minBufferSize, remaining)];
}
while (remaining > 0) {
int bytesRead;
int chunkSize = (int)Math.Min(minBufferSize, remaining);
if (srcStream != null) {
userBuffer = null;
bytesRead = srcStream.Read(buffer, 0, chunkSize);
} else {
userBuffer = MutableString.CreateBinary();
bytesRead = Protocols.CastToFixnum(toInt, readSite.Target(readSite, src, chunkSize, userBuffer));
}
if (bytesRead <= 0) {
break;
}
if (dstStream != null) {
if (userBuffer != null) {
dstStream.Write(userBuffer, 0, bytesRead);
} else {
dstStream.Write(buffer, 0, bytesRead);
}
} else {
if (userBuffer == null) {
userBuffer = MutableString.CreateBinary(bytesRead).Append(buffer, 0, bytesRead);
} else {
userBuffer.SetByteCount(bytesRead);
}
writeSite.Target(writeSite, dst, userBuffer);
}
bytesCopied += bytesRead;
remaining -= bytesRead;
}
return Protocols.Normalize(bytesCopied);
} finally {
if (srcStream != null) {
srcStream.Close();
}
if (dstStream != null) {
dstStream.Close();
}
}
}
public static bool Equal(BinaryOpStorage /*!*/ equals, double self, object other)
{
// Call == on the right operand like Float#== does
return(Protocols.IsEqual(equals, other, self));
}
public static int SysWrite(BinaryOpStorage/*!*/ writeStorage, ConversionStorage<MutableString>/*!*/ tosConversion,
RubyContext/*!*/ context, RubyIO/*!*/ self, object obj) {
return SysWrite(writeStorage, tosConversion, context, self, Protocols.ConvertToString(tosConversion, obj));
}
public static object Compare(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ comparisonStorage, double self, object other)
{
return(Protocols.CoerceAndCompare(coercionStorage, comparisonStorage, self, other));
}
public static bool Contains(CallSiteStorage<EachSite>/*!*/ each, BinaryOpStorage/*!*/ equals, object self, object value) {
bool result = false;
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
if (Protocols.IsEqual(equals, item, value)) {
result = true;
return selfBlock.Break(result);
}
return null;
}));
return result;
}
public static object Subtract(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite,
BigDecimal /*!*/ self, object other, [DefaultProtocol] int n)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "sub", self, other));
}
private static object GetExtreme(
CallSiteStorage<EachSite>/*!*/ each,
BinaryOpStorage/*!*/ compareStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
BlockParam comparer, object self, int comparisonValue) {
bool firstItem = true;
object result = null;
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
// Check for first element
if (firstItem) {
result = item;
firstItem = false;
return null;
}
int compareResult;
if (comparer != null) {
object blockResult;
if (comparer.Yield(result, item, out blockResult)) {
return blockResult;
}
if (blockResult == null) {
throw RubyExceptions.MakeComparisonError(selfBlock.RubyContext, result, item);
}
compareResult = Protocols.ConvertCompareResult(lessThanStorage, greaterThanStorage, blockResult);
} else {
compareResult = Protocols.Compare(compareStorage, lessThanStorage, greaterThanStorage, result, item);
}
// Check if we have found the new minimum or maximum (-1 to select max, 1 to select min)
if (compareResult == comparisonValue) {
result = item;
}
return null;
}));
return result;
}
public static object Next(BinaryOpStorage /*!*/ addStorage, object /*!*/ self)
{
var site = addStorage.GetCallSite("+");
return(site.Target(site, self, ClrInteger.One));
}
public static RubyArray/*!*/ SortBy(
CallSiteStorage<EachSite>/*!*/ each,
BinaryOpStorage/*!*/ comparisonStorage,
BinaryOpStorage/*!*/ lessThanStorage,
BinaryOpStorage/*!*/ greaterThanStorage,
BlockParam keySelector, object self) {
// collect key, value pairs
List<KeyValuePair<object, object>> keyValuePairs = new List<KeyValuePair<object, object>>();
// Collect the key, value pairs
Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) {
if (keySelector == null) {
throw RubyExceptions.NoBlockGiven();
}
object key;
if (keySelector.Yield(item, out key)) {
return key;
}
keyValuePairs.Add(new KeyValuePair<object, object>(key, item));
return null;
}));
// sort by keys
keyValuePairs.Sort(delegate(KeyValuePair<object, object> x, KeyValuePair<object, object> y) {
return Protocols.Compare(comparisonStorage, lessThanStorage, greaterThanStorage, x.Key, y.Key);
});
// return values
RubyArray result = new RubyArray(keyValuePairs.Count);
foreach (KeyValuePair<object, object> pair in keyValuePairs) {
result.Add(pair.Value);
}
return result;
}
public static object Subtract(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, double self, object other)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "-", self, other));
}