/** * Selects the minimum value found in an Iterable of items. * * @param items an Iterable * @return the minimum value * @since 2.2.0 */ public static <T> T min(Iterable<T> items) { T answer = null; for (T value : items) { if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer)) { answer = value; } } } return answer; }
@Override public boolean hasNext() { fetchNextIfNeeded(); return (next != null) && (isAscending ? (range.inclusive ? compareLessThanEqual(next, range.getTo()) : compareLessThan(next, range.getTo())) : (range.inclusive ? compareGreaterThanEqual(next, range.getFrom()) : compareGreaterThan(next, range.getFrom()))); }
StepIterator(NumberRange range, Number step) { if (compareEqual(step, 0) && compareNotEqual(range.getFrom(), range.getTo())) { throw new GroovyRuntimeException("Infinite loop detected due to step size of 0"); } this.range = range; if (compareLessThan(step, 0)) { this.step = multiply(step, -1); isAscending = range.isReverse(); } else { this.step = step; isAscending = !range.isReverse(); } }
public void testLessThan() { assertTrue(ScriptBytecodeAdapter.compareLessThan(new Integer(1), new Integer(2))); assertTrue(ScriptBytecodeAdapter.compareLessThanEqual(new Integer(2), new Integer(2))); }
answer = item; answerValue = value; } else if (ScriptBytecodeAdapter.compareLessThan(answerValue, value)) { answer = item; answerValue = value;
answer = item; answerValue = value; } else if (ScriptBytecodeAdapter.compareLessThan(value, answerValue)) { answer = item; answerValue = value;
public void testDecrementString() throws Exception { String original = "a"; String answer = StringGroovyMethods.previous(original); assertEquals("`", answer); assertTrue(ScriptBytecodeAdapter.compareLessThan(answer, original)); }
/** * Selects the minimum value found in a collection of items. * * @param items a Collection * @return the minimum value */ public static <T> T min(Collection<T> items) { T answer = null; for (T value : items) { if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer)) { answer = value; } } } return answer; }
/** * Selects the minimum value found in a collection of items. * * @param items a Collection * @return the minimum value */ public static <T> T min(Collection<T> items) { T answer = null; for (T value : items) { if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer)) { answer = value; } } } return answer; }
/** * Selects the minimum value found in a collection of items. * * @param items a Collection * @return the minimum value */ public static Object min(Collection items) { Object answer = null; for (Iterator iter = items.iterator(); iter.hasNext();) { Object value = iter.next(); if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer)) { answer = value; } } } return answer; }
/** * Selects the minimum value found in a collection of items. * * @param items a Collection * @return the minimum value */ public static Object min(Collection items) { Object answer = null; for (Iterator iter = items.iterator(); iter.hasNext();) { Object value = iter.next(); if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer)) { answer = value; } } } return answer; }
/** * Selects the minimum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the smallest comparable value will be returned from this method * as the minimum. * * @param self a Collection * @param closure a closure used as a comparator * @return the minimum value */ public static Object min(Collection self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return min(self, new ClosureComparator(closure)); } Object answer = null; Object answer_value = null; for (Iterator iter = self.iterator(); iter.hasNext();) { Object item = iter.next(); Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer_value)) { answer = item; answer_value = value; } } return answer; }
/** * Selects the maximum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the largest comparable value will be returned from this method * as the maximum. * * @param self a Collection * @param closure a closure used as a comparator * @return the maximum value */ public static Object max(Collection self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return max(self, new ClosureComparator(closure)); } Object answer = null; Object AnswerValue = null; for (Iterator iter = self.iterator(); iter.hasNext();) { Object item = iter.next(); Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(AnswerValue, value)) { answer = item; AnswerValue = value; } } return answer; }
/** * Selects the minimum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the smallest comparable value will be returned from this method * as the minimum. * * @param self a Collection * @param closure a closure used as a comparator * @return the minimum value * @since 1.0 */ public static Object min(Collection self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return min(self, new ClosureComparator(closure)); } Object answer = null; Object answer_value = null; for (Iterator iter = self.iterator(); iter.hasNext();) { Object item = iter.next(); Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer_value)) { answer = item; answer_value = value; } } return answer; }
/** * Selects the maximum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the largest comparable value will be returned from this method * as the maximum. * * @param self a Collection * @param closure a closure used as a comparator * @return the maximum value * @since 1.0 */ public static Object max(Collection self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return max(self, new ClosureComparator(closure)); } Object answer = null; Object AnswerValue = null; for (Iterator iter = self.iterator(); iter.hasNext();) { Object item = iter.next(); Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(AnswerValue, value)) { answer = item; AnswerValue = value; } } return answer; }
/** * Selects the maximum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the largest comparable value will be returned from this method * as the maximum. * * @param self a Collection * @param closure a closure used as a comparator * @return the maximum value * @since 1.0 */ public static <T> T max(Collection<T> self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return max(self, new ClosureComparator<T>(closure)); } T answer = null; Object answerValue = null; for (T item : self) { Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(answerValue, value)) { answer = item; answerValue = value; } } return answer; }
/** * Selects the minimum value found in the collection using the given closure * as a comparator. The closure should return a comparable value (i.e. a * number) for each item passed. The collection item for which the closure * returns the smallest comparable value will be returned from this method * as the minimum. * * @param self a Collection * @param closure a closure used as a comparator * @return the minimum value * @since 1.0 */ public static <T> T min(Collection<T> self, Closure closure) { int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return min(self, new ClosureComparator<T>(closure)); } T answer = null; Object answer_value = null; for (T item : self) { Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer_value)) { answer = item; answer_value = value; } } return answer; }
for (T item : self) { Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(answerValue, value)) { answer = item; answerValue = value;
for (T item : self) { Object value = closure.call(item); if (answer == null || ScriptBytecodeAdapter.compareLessThan(value, answer_value)) { answer = item; answer_value = value;