Java Code Examples for groovy.lang.Closure#setDelegate()

public void execute(T delegate) {
    if (closure == null) {
        return;
    }

    try {
        if (configureableAware && delegate instanceof Configurable) {
            ((Configurable)delegate).configure(closure);
        } else {
            Closure copy = (Closure) closure.clone();
            copy.setResolveStrategy(resolveStrategy);
            copy.setDelegate(delegate);
            if (copy.getMaximumNumberOfParameters() == 0) {
                copy.call();
            } else {
                copy.call(delegate);
            }
        }
    } catch (groovy.lang.MissingMethodException e) {
        if (e.getType().equals(closure.getClass()) && e.getMethod().equals("doCall")) {
            throw new InvalidActionClosureException(closure, delegate);
        }
    }
}
 

/**
 * Sets the current ReferenceResolver.<br>
 * It will assign DefaultReferenceResolver if null.<br>
 * It accepts a ReferenceResolver instance, a String or a Closure.
 */
public void setReferenceResolver(final Object referenceResolver) {
    if (referenceResolver instanceof ReferenceResolver) {
        this.referenceResolver = (ReferenceResolver) referenceResolver;
    } else if (referenceResolver instanceof String) {
        this.referenceResolver = nodeName -> (String) referenceResolver;
    } else if (referenceResolver instanceof Closure) {
        final ObjectGraphBuilder self = this;
        this.referenceResolver = nodeName -> {
            Closure cls = (Closure) referenceResolver;
            cls.setDelegate(self);
            return (String) cls.call(new Object[]{nodeName});
        };
    } else {
        this.referenceResolver = new DefaultReferenceResolver();
    }
}
 

public TestCaseProcess process(Closure<?> cl) throws TestException {
    cl.setResolveStrategy(Closure.DELEGATE_FIRST);
    cl.setDelegate(process);
    cl.call();
    if (getTestCaseRun().testCaseProcess == null)
        getTestCaseRun().testCaseProcess = process;
    return process;
}
 

@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;
}
 

/**
 * Factory method for creating <code>JsonDelegate</code>s from closures.
 *
 * @param c closure representing JSON objects
 * @return an instance of <code>JsonDelegate</code>
 */
public static Map<String, Object> cloneDelegateAndGetContent(Closure<?> c) {
    JsonDelegate delegate = new JsonDelegate();
    Closure<?> cloned = (Closure<?>) c.clone();
    cloned.setDelegate(delegate);
    cloned.setResolveStrategy(Closure.DELEGATE_FIRST);
    cloned.call();

    return delegate.getContent();
}
 

public void registerExplicitProperty(String name, String groupName, Closure getter, Closure setter) {
    // set the delegate to FBS so the closure closes over the builder
    if (getter != null) getter.setDelegate(this);
    if (setter != null) setter.setDelegate(this);
    explicitProperties.put(name, new Closure[]{getter, setter});
    String methodNameBase = capitalize(name);
    if (getter != null) {
        getRegistrationGroup(groupName).add("get" + methodNameBase);
    }
    if (setter != null) {
        getRegistrationGroup(groupName).add("set" + methodNameBase);
    }
}
 

public void delay(Closure<?> config) {
   ReflexDelayContext ctx = new ReflexDelayContext(this);
   try (ReflexActionPop pop = new ReflexActionPop(ctx)) {
      config.setDelegate(ctx);
      config.call();
   } finally {
      addAction(ctx.delayed);
   }
}
 

public IssueType findIssueType(@DelegatesTo(FindIssueTypeHandler.class) Closure closure) {
    FindIssueTypeHandler findIssueTypeHandler = new FindIssueTypeHandler();
    closure.setDelegate(findIssueTypeHandler);
    closure.call();

    ConstantsManager constantsManager = (ConstantsManager) closure.getProperty("constantsManager");
    Collection<IssueType> allIssueTypeObjects =  constantsManager.getAllIssueTypeObjects();
    for (IssueType issueType : allIssueTypeObjects) {
        if (issueType.getName().equals(findIssueTypeHandler.name)) {
            return issueType;
        }
    }
    return null;
}
 

/**
 * Closure for applying properties to the Swarm configuration.
 */
public void properties(Closure<Properties> closure) {
    ConfigObject config = new ConfigObject();
    closure.setResolveStrategy(Closure.DELEGATE_ONLY);
    closure.setDelegate(config);
    closure.call();
    config.flatten(this.properties);
}
 

public void properties(Closure<Properties> closure) {
    ConfigObject config = new ConfigObject();
    closure.setResolveStrategy(Closure.DELEGATE_ONLY);
    closure.setDelegate(config);
    closure.call();
    config.flatten(this.properties);
}
 

/**
 * Factory method for creating <code>JsonDelegate</code>s from closures currying an object
 * argument.
 *
 * @param c closure representing JSON objects
 * @param o an object curried to the closure
 * @return an instance of <code>JsonDelegate</code>
 */
public static Map<String, Object> curryDelegateAndGetContent(Closure<?> c, Object o) {
    JsonDelegate delegate = new JsonDelegate();
    Closure<?> curried = c.curry(o);
    curried.setDelegate(delegate);
    curried.setResolveStrategy(Closure.DELEGATE_FIRST);
    curried.call();

    return delegate.getContent();
}
 

private static void curryDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, Object o, boolean first, JsonGenerator generator) {
    StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first, generator);
    Closure curried = c.curry(o);
    curried.setDelegate(delegate);
    curried.setResolveStrategy(Closure.DELEGATE_FIRST);
    curried.call();
}
 

public void compiler(Closure<?> configureAction) {
  configureAction.setResolveStrategy(Closure.DELEGATE_FIRST);
  configureAction.setDelegate(compiler);
  configureAction.call(compiler);
}
 

/**
 * The query parameters part of the contract.
 * @param consumer function to manipulate the query parameters
 */
public void queryParameters(@DelegatesTo(QueryParameters.class) Closure consumer) {
	this.queryParameters = new QueryParameters();
	consumer.setDelegate(this.queryParameters);
	consumer.call();
}
 

void closureInit(Closure cl, Object delegate) {
    cl.setDelegate(delegate);
    cl.call();
}
 

void closureInit(Closure cl, Object delegate) {
    cl.setDelegate(delegate);
    cl.call();
}
 

/**
 * The message headers part of the contract.
 * @param consumer function to manipulate the message headers
 */
public void messageHeaders(@DelegatesTo(Headers.class) Closure consumer) {
	this.messageHeaders = new Headers();
	consumer.setDelegate(this.messageHeaders);
	consumer.call();
}
 

public void ordered(Closure<?> closure) {
   ZWaveSendOrdered ctx = new ZWaveSendOrdered(GroovyCapabilityDefinition.CapabilityHandlerContext.getContext(this));
   closure.setResolveStrategy(Closure.DELEGATE_FIRST);
   closure.setDelegate(ctx);
   closure.call();
}
 

/**
 * Allows to set matchers for the body.
 * @param consumer function to manipulate the URL
 */
public void bodyMatchers(@DelegatesTo(ResponseBodyMatchers.class) Closure consumer) {
	this.bodyMatchers = new ResponseBodyMatchers();
	consumer.setDelegate(this.bodyMatchers);
	consumer.call();
}
 

/**
 * Creates an `HttpBuilder` configured with the provided configuration closure, using the `defaultFactory` as the client factory.
 *
 * The configuration closure delegates to the {@link HttpObjectConfig} interface, which is an extension of the {@link HttpConfig} interface -
 * configuration properties from either may be applied to the global client configuration here. See the documentation for those interfaces for
 * configuration property details.
 *
 * [source,groovy]
 * ----
 * def factory = { c -> new ApacheHttpBuilder(c); } as Function
 *
 * def http = HttpBuilder.configure(factory){
 *     request.uri = 'http://localhost:10101'
 * }
 * ----
 *
 * @param factory the {@link HttpObjectConfig} factory function ({@link JavaHttpBuilder} or {@link groovyx.net.http.ApacheHttpBuilder})
 * @param closure the configuration closure (delegated to {@link HttpObjectConfig})
 * @return the configured `HttpBuilder`
 */
public static HttpBuilder configure(final Function<HttpObjectConfig, ? extends HttpBuilder> factory, @DelegatesTo(HttpObjectConfig.class) final Closure closure) {
    HttpObjectConfig impl = new HttpObjectConfigImpl();
    closure.setDelegate(impl);
    closure.setResolveStrategy(Closure.DELEGATE_FIRST);
    closure.call();
    return factory.apply(impl);
}