public Object callGroovyObjectGetProperty(Object receiver) throws Throwable { if (receiver == null) { try { return InvokerHelper.getProperty(NullObject.getNullObject(), name); } catch (GroovyRuntimeException gre) { throw ScriptBytecodeAdapter.unwrap(gre); } } else { return acceptGroovyObjectGetProperty(receiver).getProperty(receiver); } }
public static boolean compareNotEqual(Object left, Object right) { return !compareEqual(left, right); }
public static Object getFieldSafe(Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return null; return getField(senderClass, receiver, messageName); }
public static List createRange(Object from, Object to, boolean inclusive) throws Throwable { if (from instanceof Integer && to instanceof Integer) { int ifrom = (Integer) from; int ito = (Integer) to; if (inclusive || ifrom != ito) { return new IntRange(inclusive, ifrom, ito); } // else fall through for EmptyRange } if (!inclusive && compareEqual(from, to)) { return new EmptyRange((Comparable) from); } if (from instanceof Number && to instanceof Number) { return new NumberRange(comparableNumber((Number) from), comparableNumber((Number) to), inclusive); } if (!inclusive) { if (compareGreaterThan(from, to)) { to = invokeMethod0(ScriptBytecodeAdapter.class, to, "next"); } else { to = invokeMethod0(ScriptBytecodeAdapter.class, to, "previous"); } } return new ObjectRange((Comparable) from, (Comparable) to); }
@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 static List createRange(Object from, Object to, boolean inclusive) throws Throwable { if (!inclusive) { if (compareEqual(from, to)) { return new EmptyRange((Comparable) from); } if (compareGreaterThan(from, to)) { to = invokeMethod0(ScriptBytecodeAdapter.class, to, "next"); } else { to = invokeMethod0(ScriptBytecodeAdapter.class, to, "previous"); } } if (from instanceof Integer && to instanceof Integer) { return new IntRange(DefaultTypeTransformation.intUnbox(from), DefaultTypeTransformation.intUnbox(to)); } else { return new ObjectRange((Comparable) from, (Comparable) to); } }
public static void setPropertySafe(Object messageArgument, Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return; setProperty(messageArgument, senderClass, receiver, messageName); }
public static void setGroovyObjectPropertySpreadSafe(Object messageArgument, Class senderClass, GroovyObject receiver, String messageName) throws Throwable { if (receiver == null) return; if (!isSpreadable(receiver)) { setProperty(messageArgument, senderClass, receiver, messageName); return; } for (Iterator it = InvokerHelper.asIterator(receiver); it.hasNext();) { setPropertySafe(messageArgument, senderClass, it.next(), messageName); } }
public static Object getPropertySafe(Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return null; return getProperty(senderClass, receiver, messageName); }
/** * Selects the maximum value found in an Iterable. * * @param items a Collection * @return the maximum value * @since 2.2.0 */ public static <T> T max(Iterable<T> items) { T answer = null; for (T value : items) { if (value != null) { if (answer == null || ScriptBytecodeAdapter.compareGreaterThan(value, answer)) { answer = value; } } } return answer; }
/** * 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; }
public void testGreaterThan() { assertTrue(ScriptBytecodeAdapter.compareGreaterThan(new Integer(3), new Integer(2))); assertTrue(ScriptBytecodeAdapter.compareGreaterThanEqual(new Integer(2), new Integer(2))); }
public void testLessThan() { assertTrue(ScriptBytecodeAdapter.compareLessThan(new Integer(1), new Integer(2))); assertTrue(ScriptBytecodeAdapter.compareLessThanEqual(new Integer(2), new Integer(2))); }
public static Object getPropertySpreadSafe(Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return null; if (!isSpreadable(receiver)) return getProperty(senderClass, receiver, messageName); List answer = new ArrayList(); for (Iterator it = InvokerHelper.asIterator(receiver); it.hasNext();) { answer.add(getPropertySafe(senderClass, it.next(), messageName)); } return answer; }
public static void setFieldSafe(Object messageArgument, Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return; setField(messageArgument, senderClass, receiver, messageName); }
public static Object getFieldSpreadSafe(Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return null; if (!isSpreadable(receiver)) return getField(senderClass, receiver, messageName); List list = (List) receiver; List answer = new ArrayList(); for (Iterator it = list.iterator(); it.hasNext();) { answer.add(getFieldSafe(senderClass, it.next(), messageName)); } return answer; }
/** * Checks whether a value is between the from and to values of a Range * * @param value the value of interest * @return true if the value is within the bounds */ @Override public boolean containsWithinBounds(Object value) { final int result = compareTo(from, value); return result == 0 || result < 0 && compareTo(to, value) >= 0; }
public Next loopHead(Object col) { try { itr = (Iterator) ScriptBytecodeAdapter.invokeMethod0(null/*unused*/, col, "iterator"); } catch (Throwable t) { return throwException(e, t, loc, new ReferenceStackTrace()); } return increment(null); }
public static void setFieldSpreadSafe(Object messageArgument, Class senderClass, Object receiver, String messageName) throws Throwable { if (receiver == null) return; if (!isSpreadable(receiver)) { setField(messageArgument, senderClass, receiver, messageName); return; } for (Iterator it = InvokerHelper.asIterator(receiver); it.hasNext();) { setFieldSafe(messageArgument, senderClass, it.next(), messageName); } }