Tabnine Logo
JavaForkOptions
Code IndexAdd Tabnine to your IDE (free)

How to use
JavaForkOptions
in
org.gradle.process

Best Java code snippets using org.gradle.process.JavaForkOptions (Showing top 20 results out of 315)

origin: org.gradle/gradle-core

public void copyTo(JavaForkOptions target) {
  target.setJvmArgs(extraJvmArgs);
  target.setSystemProperties(mutableSystemProperties);
  target.setMinHeapSize(minHeapSize);
  target.setMaxHeapSize(maxHeapSize);
  target.setBootstrapClasspath(getBootstrapClasspath());
  target.setEnableAssertions(assertionsEnabled);
  target.setDebug(debug);
  target.systemProperties(immutableSystemProperties);
}
origin: org.gradle/gradle-core

public void setDefaultCharacterEncoding(String defaultCharacterEncoding) {
  javaOptions.setDefaultCharacterEncoding(defaultCharacterEncoding);
}
origin: org.gradle/gradle-core

public JavaExecHandleBuilder jvmArgs(Object... arguments) {
  javaOptions.jvmArgs(arguments);
  return this;
}
origin: gradle.plugin.com.github.anolivetree/gradle-clojure-plugin

private void start() {
 workerExecutor.submit(config -> {
  config.setClasspath(getClasspath());
  config.setNamespace("gradle-clojure.tools.clojure-nrepl");
  config.setFunction("start!");
  config.setArgs(port, controlPort);
  config.forkOptions(fork -> {
   fork.setJvmArgs(getForkOptions().getJvmArgs());
   fork.setMinHeapSize(getForkOptions().getMemoryInitialSize());
   fork.setMaxHeapSize(getForkOptions().getMemoryMaximumSize());
   fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
  });
 });
}
origin: gradle.plugin.com.github.spotbugs/spotbugs-gradle-plugin

@TaskAction
public void run() {
  new SpotBugsClasspathValidator(JavaVersion.current()).validateClasspath(
      getSpotbugsClasspath().getFiles().stream().map(File::getName).collect(Collectors.toSet()));
  SpotBugsSpec spec = generateSpec();
  //workaround for https://github.com/spotbugs/spotbugs-gradle-plugin/issues/61
  if(reports.getEnabledReports().isEmpty()) {
    getProject().getLogger().lifecycle("WARNING: No SpotBugs report(s) were configured; aborting execution of {}", getPath());
    return;
  }
  workerExecutor.submit(SpotBugsRunner.class, config -> {
    config.params(spec, getIgnoreFailures(), reports.getFirstEnabled().getDestination());
    config.setClasspath(getSpotbugsClasspath());
    config.setForkMode(ForkMode.ALWAYS);
    config.forkOptions( options -> {
      options.setDebug(spec.isDebugEnabled());
      options.setJvmArgs(spec.getJvmArgs());
      options.setMaxHeapSize(spec.getMaxHeapSize());
    });
    config.setIsolationMode(IsolationMode.PROCESS);
  });
}
origin: org.gradle/gradle-core

public void setJvmArgs(List<String> arguments) {
  javaOptions.setJvmArgs(arguments);
}
origin: org.gradle/gradle-core

public void setMaxHeapSize(String heapSize) {
  javaOptions.setMaxHeapSize(heapSize);
}
origin: org.gradle/gradle-core

public void setMinHeapSize(String heapSize) {
  javaOptions.setMinHeapSize(heapSize);
}
origin: org.gradle/gradle-core

public JavaExecHandleBuilder systemProperty(String name, Object value) {
  javaOptions.systemProperty(name, value);
  return this;
}
origin: dodie/scott

@Override
public void apply(Project project) {
  ScottPluginExtension extension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, ScottPluginExtension.class, DEFAULT_SCOTT_VERSION);
  Configuration configuration = configureAgentDependencies(project,extension);
  project.afterEvaluate( p -> {
    Task test = p.getTasks().getByName("test");
    JavaForkOptions opts = (JavaForkOptions)test;
    opts.getJvmArgumentProviders().add(new ScottAgent(configuration,extension));
  });
}
origin: org.gradle/gradle-core

public void setDebug(boolean enabled) {
  javaOptions.setDebug(enabled);
}
origin: io.github.gradle-clojure/gradle-clojure-plugin

 @TaskAction
 public void compile() {
  File outputDir = getDestinationDir().get().getAsFile();
  if (!getProject().delete(outputDir)) {
   throw new GradleException("Cannot clean destination directory: " + outputDir.getAbsolutePath());
  }
  if (!outputDir.mkdirs()) {
   throw new GradleException("Cannot create destination directory: " + outputDir.getAbsolutePath());
  }

  FileCollection classpath = getClasspath().plus(getSourceRoots());

  clojureExecutor.exec(spec -> {
   spec.setClasspath(classpath);
   spec.setMain("gradle-clojure.tools.clojurescript-compiler");
   spec.args(getSourceRoots(), getOptions());
   spec.forkOptions(fork -> {
    fork.setJvmArgs(forkOptions.getJvmArgs());
    fork.setMinHeapSize(forkOptions.getMemoryInitialSize());
    fork.setMaxHeapSize(forkOptions.getMemoryMaximumSize());
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}
origin: org.gradle/gradle-core

public void setJvmArgs(Iterable<?> arguments) {
  javaOptions.setJvmArgs(arguments);
}
origin: gradle.plugin.com.github.anolivetree/gradle-clojure-plugin

public void submit(Action<ClojureWorkerConfiguration> action) {
 ClojureWorkerConfiguration config = new ClojureWorkerConfiguration();
 action.execute(config);
 FileCollection realClasspath = config.getClasspath().plus(resolveShim());
 workerExecutor.submit(ClojureWorker.class, worker -> {
  worker.setIsolationMode(IsolationMode.PROCESS);
  worker.params(config.getNamespace(), config.getFunction(), config.getArgs());
  config.getConfigureFork().forEach(worker::forkOptions);
  worker.forkOptions(fork -> fork.systemProperty("shim.classpath", realClasspath.getAsPath()));
  worker.classpath(resolveWorker());
 });
}
origin: gradle.plugin.hu.advanceweb/scott-gradle-plugin

@Override
public void apply(Project project) {
  ScottPluginExtension extension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, ScottPluginExtension.class, DEFAULT_SCOTT_VERSION);
  Configuration configuration = configureAgentDependencies(project,extension);
  project.afterEvaluate( p -> {
    Task test = p.getTasks().getByName("test");
    JavaForkOptions opts = (JavaForkOptions)test;
    opts.getJvmArgumentProviders().add(new ScottAgent(configuration,extension));
  });
}
origin: gradle-clojure/gradle-clojure

 @TaskAction
 public void compile() {
  File outputDir = getDestinationDir().get().getAsFile();
  if (!getProject().delete(outputDir)) {
   throw new GradleException("Cannot clean destination directory: " + outputDir.getAbsolutePath());
  }
  if (!outputDir.mkdirs()) {
   throw new GradleException("Cannot create destination directory: " + outputDir.getAbsolutePath());
  }

  FileCollection classpath = getClasspath().plus(getSourceRoots());

  clojureExecutor.exec(spec -> {
   spec.setClasspath(classpath);
   spec.setMain("gradle-clojure.tools.clojurescript-compiler");
   spec.args(getSourceRoots(), getOptions());
   spec.forkOptions(fork -> {
    fork.setJvmArgs(forkOptions.getJvmArgs());
    fork.setMinHeapSize(forkOptions.getMemoryInitialSize());
    fork.setMaxHeapSize(forkOptions.getMemoryMaximumSize());
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}
origin: org.gradle/gradle-core

public JavaExecHandleBuilder jvmArgs(Iterable<?> arguments) {
  javaOptions.jvmArgs(arguments);
  return this;
}
origin: gradle.plugin.com.github.anolivetree/gradle-clojure-plugin

 @TaskAction
 public void exec() {
  workerExecutor.submit(config -> {
   config.setClasspath(getClasspath());
   config.setNamespace(getNamespace());
   config.setFunction(getFunction());
   config.setArgs(getArgs().toArray(new Object[getArgs().size()]));
   config.forkOptions(fork -> {
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}
origin: io.github.gradle-clojure/gradle-clojure-plugin

private void start() {
 if (!getProject().delete(getTemporaryDir())) {
  throw new GradleException("Cannot clean temporary directory: " + getTemporaryDir().getAbsolutePath());
 }
 FileCollection cp = getProject().files(getTemporaryDir(), getClasspath());
 List<String> middleware = Stream.of(defaultMiddleware.getOrElse(Collections.emptyList()), userMiddleware.getOrElse(Collections.emptyList()))
   .flatMap(List::stream)
   .collect(Collectors.toList());
 clojureExecutor.exec(spec -> {
  spec.setClasspath(cp);
  spec.setMain("gradle-clojure.tools.clojure-nrepl");
  spec.setArgs(port, controlPort, handler.getOrNull(), middleware, Edn.keywordize(contextData));
  spec.forkOptions(fork -> {
   fork.setJvmArgs(getForkOptions().getJvmArgs());
   fork.setMinHeapSize(getForkOptions().getMemoryInitialSize());
   fork.setMaxHeapSize(getForkOptions().getMemoryMaximumSize());
   fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
  });
 });
}
origin: gradle.plugin.de.lukaskoerfer.gradle/debugging

@TaskAction
private void setupDebug() throws IOException {
  target.jvmArgs(debugSpec.getJvmArgs());
}
org.gradle.processJavaForkOptions

Most used methods

  • setJvmArgs
  • setMaxHeapSize
  • setDefaultCharacterEncoding
  • setMinHeapSize
  • getJvmArgumentProviders
  • jvmArgs
  • setDebug
  • systemProperty
  • bootstrapClasspath
  • copyTo
  • getAllJvmArgs
  • getBootstrapClasspath
  • getAllJvmArgs,
  • getBootstrapClasspath,
  • getDebug,
  • getDefaultCharacterEncoding,
  • getEnableAssertions,
  • getEnvironment,
  • getExecutable,
  • getJvmArgs,
  • getMaxHeapSize,
  • getMinHeapSize

Popular in Java

  • Finding current android device location
  • getApplicationContext (Context)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • getContentResolver (Context)
  • PrintStream (java.io)
    Fake signature of an existing Java class.
  • HashSet (java.util)
    HashSet is an implementation of a Set. All optional operations (adding and removing) are supported.
  • Vector (java.util)
    Vector is an implementation of List, backed by an array and synchronized. All optional operations in
  • LogFactory (org.apache.commons.logging)
    Factory for creating Log instances, with discovery and configuration features similar to that employ
  • Project (org.apache.tools.ant)
    Central representation of an Ant project. This class defines an Ant project with all of its targets,
  • Reflections (org.reflections)
    Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t
  • Top Vim plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now