public void define(Class subClass, Closure closure) { final SubClassDefiningClosure definer = new SubClassDefiningClosure(subClass); closure.setDelegate(definer); closure.setResolveStrategy(Closure.DELEGATE_FIRST); closure.call((Object)null); }
@Override public V call(Object... args) { Object temp = first.call(args); if (temp instanceof List && second.getParameterTypes().length > 1) temp = ((List) temp).toArray(); return temp instanceof Object[] ? second.call((Object[]) temp) : second.call(temp); } }
@Override public boolean onNodeChildren(final FactoryBuilderSupport builder, final Object node, final Closure childContent) { if (node instanceof SecureASTCustomizer) { Closure clone = (Closure) childContent.clone(); clone.setDelegate(node); clone.setResolveStrategy(Closure.DELEGATE_FIRST); clone.call(); } return false; } }
/** * When a method argument is only a closure it is a set of bean definitions. * @param callable the closure argument * @return this {@code GroovyBeanDefinitionReader} instance */ protected GroovyBeanDefinitionReader invokeBeanDefiningClosure(Closure callable) { callable.setDelegate(this); callable.call(); finalizeDeferredProperties(); return this; }
@Override public void $setDelegate(Object delegate) { closure.setResolveStrategy(Closure.DELEGATE_FIRST); closure.setDelegate(delegate); } };
public void build(final GroovyObject builder, final Map namespaceMap, final Map<String, String> namespaceTagHints) { final Closure c = (Closure) ((Closure) newValue).clone(); c.setDelegate(builder); c.call(new Object[]{result}); } });
int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return max(self, new ClosureComparator<T>(closure)); Object answerValue = null; for (T item : self) { Object value = closure.call(item); if (first) { first = false; answer = item; answerValue = value; } else if (ScriptBytecodeAdapter.compareLessThan(answerValue, value)) { answer = item; answerValue = value;
int params = closure.getMaximumNumberOfParameters(); if (params != 1) { return min(self, new ClosureComparator<T>(closure)); Object answerValue = null; for (T item : self) { Object value = closure.call(item); if (first) { first = false; answer = item; answerValue = value; } else if (ScriptBytecodeAdapter.compareLessThan(value, answerValue)) { answer = item; answerValue = value;
public Object getProperty(final String property) { if ("delegate".equals(property)) { return getDelegate(); } else if ("owner".equals(property)) { return getOwner(); } else if ("maximumNumberOfParameters".equals(property)) { return getMaximumNumberOfParameters(); } else if ("parameterTypes".equals(property)) { return getParameterTypes(); } else if ("metaClass".equals(property)) { return getMetaClass(); } else if ("class".equals(property)) { return getClass(); } else if ("directive".equals(property)) { return getDirective(); } else if ("resolveStrategy".equals(property)) { return getResolveStrategy(); } else if ("thisObject".equals(property)) { return getThisObject(); } else { switch(resolveStrategy) { case DELEGATE_FIRST: return getPropertyDelegateFirst(property); case DELEGATE_ONLY: return InvokerHelper.getProperty(this.delegate, property); return super.getProperty(property); default: return getPropertyOwnerFirst(property);
/** * Asserts that the given code closure fails when it is evaluated * * @param code the code expected to throw the exception * @return the message of the thrown Throwable */ public static Throwable shouldFail(Closure code) { boolean failed = false; Throwable th = null; try { code.call(); } catch (GroovyRuntimeException gre) { failed = true; th = ScriptBytecodeAdapter.unwrap(gre); } catch (Throwable e) { failed = true; th = e; } assertTrue("Closure " + code + " should have failed", failed); return th; }
public ExpandoMetaClass define(Closure closure) { final DefiningClosure definer = new DefiningClosure(); Object delegate = closure.getDelegate(); closure.setDelegate(definer); closure.setResolveStrategy(Closure.DELEGATE_ONLY); closure.call((Object)null); closure.setDelegate(delegate); closure.setResolveStrategy(Closure.DELEGATE_FIRST); definer.definition = false; return this; }
public static void curryDelegateAndGetContent(Writer w, Closure c, Object o, boolean first) { StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first); Closure curried = c.curry(o); curried.setDelegate(delegate); curried.setResolveStrategy(Closure.DELEGATE_FIRST); curried.call(); } }
private static <T> T callClosureForNode(Closure<T> closure, Object node, int level) { if (closure.getMaximumNumberOfParameters() == 2) { return closure.call(node, level); } return closure.call(node); }
@SuppressWarnings("unused") @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value="UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS",justification="Closure invokes this via reflection") public Object doCall(Object[] args) throws ChannelClosedException { if (args.length == 1 && args[0] instanceof ChannelClosedException) { throw (ChannelClosedException)args[0]; } return originalErrorHook.call(args); } });
public void handleNotification(Notification notification, Object handback) { AttributeChangeNotification note = (AttributeChangeNotification) notification; Map event = (Map) handback; if (event != null) { Object del = event.get("managedObject"); Object callback = event.get("callback"); if (callback != null && callback instanceof Closure) { Closure closure = (Closure) callback; closure.setDelegate(del); if (closure.getMaximumNumberOfParameters() == 1) closure.call(buildAttributeNotificationPacket(note)); else closure.call(); } } }
private String execute(final PreciseShardingValue shardingValue) { Closure<?> result = closure.rehydrate(new Expando(), null, null); result.setResolveStrategy(Closure.DELEGATE_ONLY); result.setProperty(shardingValue.getColumnName(), shardingValue.getValue()); return result.call().toString(); }
public void testListArithmetic() { List<List> numLists = new ArrayList<List>(); numLists.add(Arrays.asList(1, 2, 3)); numLists.add(Arrays.asList(10, 20, 30)); assertEquals(Arrays.asList(6, 60), collect(numLists, new Closure<Integer>(null) { public Integer doCall(Integer a, Integer b, Integer c) { return a + b + c; } })); Closure<Integer> arithmeticClosure = new Closure<Integer>(null) { public Integer doCall(Integer a, Integer b, Integer c) { return a * b + c; } }; Closure<Integer> tensAndUnits = arithmeticClosure.curry(10); assertEquals(35, (int) tensAndUnits.call(3, 5)); tensAndUnits = arithmeticClosure.ncurry(0, 10); assertEquals(35, (int) tensAndUnits.call(3, 5)); tensAndUnits = arithmeticClosure.ncurry(1, 10); assertEquals(35, (int) tensAndUnits.call(3, 5)); Closure<Integer> timesPlus5 = arithmeticClosure.rcurry(5); assertEquals(35, (int) timesPlus5.call(15, 2)); timesPlus5 = arithmeticClosure.ncurry(2, 5); assertEquals(35, (int) timesPlus5.call(15, 2)); }
private static <T> Collection<T> flatten(Iterable elements, Collection<T> addTo, Closure<? extends T> flattenUsing) { for (Object element : elements) { if (element instanceof Collection) { flatten((Collection) element, addTo, flattenUsing); } else if (element != null && element.getClass().isArray()) { flatten(DefaultTypeTransformation.arrayAsCollection(element), addTo, flattenUsing); } else { T flattened = flattenUsing.call(new Object[]{element}); boolean returnedSelf = flattened == element; if (!returnedSelf && flattened instanceof Collection) { List<?> list = toList((Iterable<?>) flattened); if (list.size() == 1 && list.get(0) == element) { returnedSelf = true; } } if (flattened instanceof Collection && !returnedSelf) { flatten((Collection) flattened, addTo, flattenUsing); } else { addTo.add(flattened); } } } return addTo; }
/** * {@inheritDoc} */ @Override public void step(int numSteps, Closure closure) { if (numSteps == 0 && compareTo(from, to) == 0) { return; // from == to and step == 0, nothing to do, so return } final StepIterator iter = new StepIterator(this, multiply(numSteps, stepSize)); while (iter.hasNext()) { closure.call(iter.next()); } }