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

/**
 * 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();
    }
}
 

/**
 * Processes each descendant file in this directory and any sub-directories.
 * Processing consists of potentially calling <code>closure</code> passing it the current
 * file (which may be a normal file or subdirectory) and then if a subdirectory was encountered,
 * recursively processing the subdirectory. Whether the closure is called is determined by whether
 * the file was a normal file or subdirectory and the value of fileType.
 *
 * @param self     a File (that happens to be a folder/directory)
 * @param fileType if normal files or directories or both should be processed
 * @param closure  the closure to invoke on each file
 * @throws FileNotFoundException    if the given directory does not exist
 * @throws IllegalArgumentException if the provided File object does not represent a directory
 * @since 1.7.1
 */
public static void eachFileRecurse(final File self, final FileType fileType, @ClosureParams(value = SimpleType.class, options = "java.io.File") final Closure closure)
        throws FileNotFoundException, IllegalArgumentException {
    checkDir(self);
    final File[] files = self.listFiles();
    // null check because of http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4803836
    if (files == null) return;
    for (File file : files) {
        if (file.isDirectory()) {
            if (fileType != FileType.FILES) closure.call(file);
            eachFileRecurse(file, fileType, closure);
        } else if (fileType != FileType.DIRECTORIES) {
            closure.call(file);
        }
    }
}
 

private Object unwrap(Object value) {
    while (true) {
        if (value instanceof Callable) {
            Callable callable = (Callable) value;
            try {
                value = callable.call();
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        } else if (value instanceof Closure) {
            Closure closure = (Closure) value;
            value = closure.call();
        } else if (value instanceof FileCollection) {
            FileCollection fileCollection = (FileCollection) value;
            return fileCollection.getFiles();
        } else {
            return value;
        }
    }
}
 

/**
 * Allows this writer to be used within the closure, ensuring that it
 * is flushed and closed before this method returns.
 *
 * @param writer  the writer which is used and then closed
 * @param closure the closure that the writer is passed into
 * @return the value returned by the closure
 * @throws IOException if an IOException occurs.
 * @since 1.5.2
 */
public static <T> T withWriter(Writer writer, @ClosureParams(FirstParam.class) Closure<T> closure) throws IOException {
    try {
        T result = closure.call(writer);

        try {
            writer.flush();
        } catch (IOException e) {
            // try to continue even in case of error
        }
        Writer temp = writer;
        writer = null;
        temp.close();
        return result;
    } finally {
        closeWithWarning(writer);
    }
}
 

public GroovySessionFile withReader(String charset, Closure c) throws IOException, UnsupportedCharsetException {
    InputStream inStream = session.read(this);
    BufferedReader br = new BufferedReader(new InputStreamReader(inStream, charset));
    c.call(br);
    br.close();
    return this;
}
 

/**
 * 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();
}
 

/**
 * Iterates from the date represented by this calendar up to the date represented
 * by the given calendar, inclusive, incrementing by one day each time.
 *
 * @param self    a Calendar
 * @param to      another Calendar to go up to
 * @param closure the closure to call
 * @since 2.2
 */
public static void upto(Calendar self, Calendar to, Closure closure) {
    if (self.compareTo(to) <= 0) {
        for (Calendar i = (Calendar) self.clone(); i.compareTo(to) <= 0; i = next(i)) {
            closure.call(i);
        }
    } else
        throw new GroovyRuntimeException("The argument (" + to +
                ") to upto() cannot be earlier than the value (" + self + ") it's called on.");
}
 

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 GroovyIndicatorValue forEach(Closure closure) {
    BarSeries series = indicator.getBarSeries();
    List<Num> values = new ArrayList<>(series.getBarCount());
    for(int i=series.getBeginIndex(); i<=series.getEndIndex();i++) {
        Num num = indicator.getValue(i);
        Number n = (Number)closure.call(num.getDelegate());
        values.add(series.function().apply(n));
    }
    return new GroovyIndicatorValue(new SimpleIndicator(series, values));
}
 

private ChainedHttpConfig configureRequest(final Class<?> type, final HttpVerb verb, final Closure closure) {
    final HttpConfigs.BasicHttpConfig myConfig = HttpConfigs.requestLevel(getObjectConfig());
    closure.setDelegate(myConfig);
    closure.setResolveStrategy(Closure.DELEGATE_FIRST);
    closure.call();

    myConfig.getChainedRequest().setVerb(verb);
    myConfig.getChainedResponse().setType(type);

    return myConfig;
}
 

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 static <T> Predicate<T> predicateFromClosure(final Closure<Boolean> job) {
    return new Predicate<T>() {
        @Override
        public boolean apply(Object input) {
            return job.call(input);
        }
    };
}
 

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

public void call(Closure<?> configClosure) {
   configClosure.setDelegate(configContext);
   configClosure.call();
}
 

protected void runAfter() throws Exception {
    final Closure<?> after = _after;
    if (after != null) {
        after.call();
    }
}
 

public void on(Map<String,Object> vals, Closure<?> action) {
   action.call(new Object[] { getProtocolMatchProcessor(), vals });
}
 

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

/**
 * Allows to configure HTTP headers.
 * @param consumer function to manipulate the URL
 */
public void headers(@DelegatesTo(Headers.class) Closure consumer) {
	this.headers = new Response.ResponseHeaders();
	consumer.setDelegate(this.headers);
	consumer.call();
}
 

/**
 * responder closure call is delayed until stub server calls back
 */
public TestCaseAdapterStub adapter(Closure<Boolean> matcher, Closure<String> responder, Closure<?> init) throws TestException {
    final TestCaseAdapterStub adapterStub = new TestCaseAdapterStub(matcher, responder);
    if (init != null) {
        init.setResolveStrategy(Closure.DELEGATE_FIRST);
        init.setDelegate(adapterStub);
        init.call();
    }
    if (responder == null) {
        adapterStub.setResponder(new Closure<String>(this, adapterStub) {
            @Override
            public String call(Object request) {
                // binding for request
                final TestCaseRun testCaseRun = getTestCaseRun();
                if (adapterStub.getResponse().contains("${")) {
                    try {
                        Binding binding = getBinding();
                        if (request.toString().startsWith("{")) {
                            Object req = new JsonSlurper().parseText(request.toString());
                            binding.setVariable("request", req);
                        }
                        else {
                            GPathResult gpathRequest = new XmlSlurper().parseText(request.toString());
                            binding.setVariable("request", gpathRequest);
                        }
                        CompilerConfiguration compilerCfg = new CompilerConfiguration();
                        compilerCfg.setScriptBaseClass(DelegatingScript.class.getName());
                        GroovyShell shell = new GroovyShell(TestCaseScript.class.getClassLoader(), binding, compilerCfg);
                        shell.setProperty("out", testCaseRun.getLog());
                        DelegatingScript script = (DelegatingScript) shell.parse("return \"\"\"" + adapterStub.getResponse() + "\"\"\"");
                        script.setDelegate(TestCaseScript.this);
                        return script.run().toString();
                    }
                    catch (Exception ex) {
                        getTestCaseRun().getLog().println("Cannot perform stub substitutions for request: " + request);
                        ex.printStackTrace(getTestCaseRun().getLog());
                    }
                }
                return adapterStub.getResponse();
            }
        });
    }
    return adapterStub;
}
 

/**
 * Iterates through the given CharSequence line by line, splitting each line using
 * the given separator Pattern.  The list of tokens for each line is then passed to
 * the given closure.
 *
 * @param self    a CharSequence
 * @param pattern the regular expression Pattern for the delimiter
 * @param closure a closure
 * @return the last value returned by the closure
 *
 * @since 1.8.2
 */
public static <T> T splitEachLine(final CharSequence self, final Pattern pattern, @ClosureParams(value=FromString.class,options={"List<String>","String[]"},conflictResolutionStrategy=PickFirstResolver.class) final Closure<T> closure) {
    T result = null;
    for (String line : new LineIterable(self)) {
        List vals = Arrays.asList(pattern.split(line));
        result = closure.call(vals);
    }
    return result;
}