implab/gradle-common Commit - r13:59dae0731c45

WIP exec api

cin -

r13:59dae0731c45 default

parent child

Context file:

r13:59dae0731c45

Collapse all files

common/src/main/java/org/implab/gradle/common/dsl/RedirectFromSpec.java +18 0

             package org.implab.gradle.common.dsl;
+            import java.io.File;
+            import java.io.InputStream;
             import java.util.Optional;
             import java.util.function.Supplier;
             import org.gradle.api.provider.Provider;
             import org.implab.gradle.common.exec.RedirectFrom;
             public class RedirectFromSpec {
                 private Supplier<RedirectFrom> streamRedirect;
                 public boolean isRedirected() {
                     return streamRedirect != null;
                 }
                 public Optional<RedirectFrom> getRedirection() {
                     return streamRedirect != null ? Optional.ofNullable(streamRedirect.get()) : Optional.empty();
                 }
+                public void fromFile(File file) {
+                    this.streamRedirect = () -> RedirectFrom.file(file);
+                }
+                public void fromFile(Provider<File> fileProvider) {
+                    this.streamRedirect = fileProvider.map(RedirectFrom::file)::getOrNull;
+                }
+                public void fromStream(InputStream stream) {
+                    this.streamRedirect = () -> RedirectFrom.stream(stream);
+                }
+                public void fromStream(Provider<InputStream> streamProvider) {
+                    this.streamRedirect = streamProvider.map(RedirectFrom::stream)::getOrNull;
+                }
                 public void from(Object input) {
                     if (input instanceof Provider<?> inputProvider) {
                         this.streamRedirect = inputProvider.map(RedirectFrom::any)::get;
                     } else {
                         this.streamRedirect = () -> RedirectFrom.any(input);
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/CommandBuilder.java +14 -9

             package org.implab.gradle.common.exec;
-            import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.implab.gradle.common.utils.Values;
             /** Command builder interface, used to specify the executable and parameters */
             @NonNullByDefault
             public interface CommandBuilder {
                 /** Sets the executable, the parameters are left intact. */
                 CommandBuilder executable(String executable);
-                /** Sets the specified executable and parameters, old executable and parameters
+                /**
+                 * Sets the specified executable and parameters, old executable and parameters
                  * are discarded.
                  */
                 default CommandBuilder commandLine(String executable, String... args) {
                     return executable(executable)
                             .arguments(args);
                 }
-                /** Sets the specified executable and parameters, old executable and parameters
+                /**
+                 * Sets the specified executable and parameters, old executable and parameters
                  * are discarded.
                  *
-                 * @param command The command line. Must contain at least one element (executable).
+                 * @param command The command line. Must contain at least one element
+                 *                (executable).
                  *
                  */
                 default CommandBuilder commandLine(Iterable<? extends String> command) {
                     var iterator = command.iterator();
                     // set executable
                     executable(Values.take(iterator).orElseThrow());
                     // cleat arguments
                     arguments();
                     // set new arguments
                     while (iterator.hasNext())
                         addArguments(iterator.next());
                     return this;
                 }
                 /** Adds the specified arguments to this builder */
-                default CommandBuilder addArguments(String arg0, String... args) {
+                CommandBuilder addArguments(String arg0, String... args);
-                    return arguments(() -> Stream
-                            .concat(Stream.of(arg0), Stream.of(args))
+                default CommandBuilder addArguments(Iterable<String> args) {
-                            .iterator());
+                    for (String arg : args)
+                        addArguments(arg);
+                    return this;
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 default CommandBuilder arguments(String... args) {
                     return arguments(Values.iterable(args));
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 CommandBuilder arguments(Iterable<String> args);
                 default CommandBuilder from(CommandSpec commandSpec) {
                     return executable(commandSpec.executable())
                             .arguments(commandSpec.arguments());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/EchoExecBuilder.java +9 -12

             package org.implab.gradle.common.exec;
             import java.io.ByteArrayInputStream;
-            import java.io.File;
             import java.io.IOException;
             import java.nio.charset.StandardCharsets;
-            import java.util.List;
-            import java.util.Map;
-            import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
+            import java.util.stream.Collectors;
             class EchoExecBuilder extends ExecBuilder {
                 private final boolean echoToStderr;
                 public EchoExecBuilder(boolean echoToStderr) {
                     this.echoToStderr = echoToStderr;
                 }
                 @Override
                 protected CompletableFuture<Integer> startInternal(
-                        Map<String, String> environment,
+                        CommandSpec command,
-                        Optional<File> directory,
+                        EnvironmentSpec environment,
-                        List<String> commandLine,
+                        PipeSpec redirect) throws IOException {
-                        Optional<RedirectFrom> stdinRedirect,
-                        Optional<RedirectTo> stdoutRedirect,
-                        Optional<RedirectTo> stderrRedirect) throws IOException {
-                    var outputRedirect = echoToStderr ? stderrRedirect : stdoutRedirect;
+                    var outputRedirect = echoToStderr ? redirect.stderr() : redirect.stdout();
                     return outputRedirect
                             .map(to -> {
-                                var bytes = String.format("exec: %s", commandLine)
+                                var bytes = String
+                                        .format(
+                                                "exec: %s",
+                                                command.commandLine().stream().collect(Collectors.joining(" ")))
                                         .getBytes(StandardCharsets.UTF_8);
                                 return to.redirect(new ByteArrayInputStream(bytes))
                                         .thenApply((x) -> 0);
                             })
                             .orElse(CompletableFuture.completedFuture(0));
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/EnvironmentBuilder.java +6 0

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.util.Map;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @NonNullByDefault
             public interface EnvironmentBuilder {
+                /** Sets the specified environment variable */
                 EnvironmentBuilder setVariable(String envVar, String value);
+                /** Replaces environment with the supplied one */
                 EnvironmentBuilder environment(Map<String, ? extends String> env);
+                /** Unsets the specified variable. If the variable is inherited it removed anyway. */
                 EnvironmentBuilder unsetVariable(String envVar);
+                /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(File directory);
+                /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(Optional<? extends File> directory);
+                /** Copies the supplied environment to this one */
                 default EnvironmentBuilder from(EnvironmentSpec environmentSpec) {
                     return environment(environmentSpec.environment())
                         .workingDirectory(environmentSpec.workingDirectory());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/ExecBuilder.java +81 -15

             package org.implab.gradle.common.exec;
             import java.util.ArrayList;
             import java.util.HashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import java.io.File;
             import java.io.IOException;
             import static java.util.Objects.requireNonNull;
             /** Command line builder */
             @NonNullByDefault
             public abstract class ExecBuilder implements
                 CommandBuilder,
                 PipeBuilder,
                 EnvironmentBuilder,
                 Runnable
             {
                 private String executable;
                 private final List<String> arguments = new ArrayList<>();
                 private final Map<String, String> environment = new HashMap<>();
                 private @Nullable File directory;
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 @Override
                 public ExecBuilder executable(String executable) {
                     requireNonNull(executable, "cmd can't be null");
                     this.executable = executable;
                     return this;
                 }
                 @Override
                 public ExecBuilder arguments(Iterable<String> args) {
                     requireNonNull(args, "Args must not be null");
                     arguments.clear();
                     for(var arg: args)
                         arguments.add(arg);
                     return this;
                 }
                 @Override
                 public ExecBuilder addArguments(String arg0, String... args) {
                     requireNonNull(arg0, "arg0 parameter can't be null");
                     arguments.add(arg0);
                     for (var arg : args)
                         arguments.add(arg);
                     return this;
                 }
                 /** Sets the working directory */
                 @Override
                 public ExecBuilder workingDirectory(File directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory;
                     return this;
                 }
                 @Override
                 public ExecBuilder workingDirectory(Optional<? extends File> directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory.orElse(null);
                     return this;
                 }
                 /**
                  * Sets the environment value. The value cannot be null.
                  *
                  * @param envVar The name of the environment variable
                  * @param value  The value to set,
                  */
                 @Override
                 public ExecBuilder setVariable(String envVar, String value) {
                     requireNonNull(value, "Value can't be null");
                     requireNonNull(envVar, "envVar parameter can't be null");
                     environment.put(envVar, value);
                     return this;
                 }
                 @Override
+                public ExecBuilder unsetVariable(String envVar) {
+                    requireNonNull(envVar, "envVar parameter can't be null");
+                    environment.remove(envVar);
+                    return this;
+                }
+                @Override
                 public ExecBuilder environment(Map<String,? extends String> env) {
                     requireNonNull(env, "env parameter can't be null");
                     environment.clear();
                     environment.putAll(env);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdin, {@link RedirectFrom} will be applied
                  * every time the process is started.
                  *
                  * <p>
                  * If redirection
                  */
                 @Override
                 public ExecBuilder stdin(RedirectFrom from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from;
                     return this;
                 }
                 @Override
-                public PipeBuilder stdin(Optional<? extends RedirectFrom> from) {
+                public ExecBuilder stdin(Optional<? extends RedirectFrom> from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdout, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stdout(RedirectTo out) {
                     requireNonNull(out, "out parameter can't be null");
                     outputRedirect = out;
                     return this;
                 }
                 @Override
-                public PipeBuilder stdout(Optional<? extends RedirectTo> to) {
+                public ExecBuilder stdout(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     outputRedirect = to.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stderr, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stderr(RedirectTo err) {
                     requireNonNull(err, "err parameter can't be null");
                     errorRedirect = err;
                     return this;
                 }
                 @Override
-                public PipeBuilder stderr(Optional<? extends RedirectTo> to) {
+                public ExecBuilder stderr(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     errorRedirect = to.orElse(null);
                     return this;
                 }
+                @Override
+                public ExecBuilder from(CommandSpec commandSpec) {
+                    CommandBuilder.super.from(commandSpec);
+                    return this;
+                }
+                @Override
+                public ExecBuilder from(PipeSpec pipeSpec) {
+                    PipeBuilder.super.from(pipeSpec);
+                    return this;
+                }
+                @Override
+                public ExecBuilder from(EnvironmentSpec environmentSpec) {
+                    EnvironmentBuilder.super.from(environmentSpec);
+                    return this;
+                }
                 /** Implement this function to */
                 protected abstract CompletableFuture<Integer> startInternal(
-                        Map<String, String> environment,
+                        CommandSpec command,
-                        Optional<File> directory,
+                        EnvironmentSpec environment,
-                        List<String> commandLine,
+                        PipeSpec redirect) throws IOException;
-                        Optional<RedirectFrom> stdinRedirect,
-                        Optional<RedirectTo> stdoutRedirect,
-                        Optional<RedirectTo> stderrRedirect) throws IOException;
                 /**
                  * Creates and starts new process and returns {@link CompletableFuture}. The
                  * process may be a remote process, or a shell process or etc.
                  *
                  * @return
                  * @throws IOException
                  */
                 public CompletableFuture<Integer> run() throws IOException {
                     if (executable == null || executable.isEmpty())
                         throw new IllegalStateException("The executable isn't set");
                     var commandLine = new ArrayList<String>();
                     commandLine.add(executable);
                     commandLine.addAll(arguments);
                     return startInternal(
-                            environment,
+                        new SelfCommandSpec(),
-                            Optional.ofNullable(directory),
+                        new SelfEnvironmentSpec(),
-                            commandLine,
+                        new SelfPipeSpec()
-                            Optional.ofNullable(inputRedirect),
+                    );
-                            Optional.ofNullable(outputRedirect),
-                            Optional.ofNullable(errorRedirect));
+                private class SelfCommandSpec implements CommandSpec {
+                    @Override
+                    public String executable() {
+                        return executable;
+                    }
+                    @Override
+                    public List<String> arguments() {
+                        return arguments;
+                    }
+                }
+                private class SelfEnvironmentSpec implements EnvironmentSpec {
+                    @Override
+                    public Map<String, String> environment() {
+                        return environment;
+                    }
+                    @Override
+                    public Optional<File> workingDirectory() {
+                        return Optional.ofNullable( directory);
+                    }
+                }
+                private class SelfPipeSpec implements PipeSpec {
+                    @Override
+                    public Optional<RedirectTo> stdout() {
+                        return Optional.ofNullable(outputRedirect);
+                    }
+                    @Override
+                    public Optional<RedirectTo> stderr() {
+                        return Optional.ofNullable(errorRedirect);
+                    }
+                    @Override
+                    public Optional<RedirectFrom> stdin() {
+                        return Optional.ofNullable(inputRedirect);
                     }
                 }
+            }

common/src/main/java/org/implab/gradle/common/exec/ExecShell.java +9 -8

             package org.implab.gradle.common.exec;
-            import java.io.File;
             import java.io.IOException;
             import java.util.List;
-            import java.util.Map;
-            import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
             import java.util.function.Consumer;
             /** Shell used to start processes */
             public interface ExecShell {
                 /** Creates new process builder {@link ExecBuilder} */
                 ExecBuilder executable();
                 /**
                  * Creates default process execution "shell" which will execute processes
                  * directly.
                  */
                 static ExecShell system() {
                     return () -> new SystemExecBuilder();
                 }
                 /**
                  * Creates a stub shell which will print command to STDERR and return 0 (no
                  * error).
                  */
                 static ExecShell echoStderr() {
                     return () -> new EchoExecBuilder(true);
                 }
                 /**
                  * Creates a stub shell which will print command to STDOUT and return 0 (no
                  * error).
                  */
                 static ExecShell echo() {
                     return () -> new EchoExecBuilder(false);
                 }
-                /** Creates a stub shell which will call the specified consumer and will supply a command line to it.
+                /**
+                 * Creates a stub shell which will call the specified consumer and will supply a
+                 * command line to it.
                  * The command line will be passed as a list of strings.
+                 *
                  * @param consumer The consumer fot the command line
                  * @return
                  */
                 static ExecShell echo(Consumer<List<String>> consumer) {
                     return () -> new ExecBuilder() {
                         @Override
-                        protected CompletableFuture<Integer> startInternal(Map<String, String> environment, Optional<File> directory,
+                        protected CompletableFuture<Integer> startInternal(
-                                List<String> commandLine, Optional<RedirectFrom> stdinRedirect, Optional<RedirectTo> stdoutRedirect,
+                                CommandSpec command,
-                                Optional<RedirectTo> stderrRedirect) throws IOException {
+                                EnvironmentSpec environment,
-                            consumer.accept(commandLine);
+                                PipeSpec redirect) throws IOException {
+                            consumer.accept(command.commandLine());
                             return CompletableFuture.completedFuture(0);
                         }
                     };
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/SystemExecBuilder.java +12 -20

             package org.implab.gradle.common.exec;
-            import java.io.File;
             import java.io.IOException;
             import java.lang.ProcessBuilder.Redirect;
             import java.util.ArrayList;
-            import java.util.List;
-            import java.util.Map;
-            import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
             class SystemExecBuilder extends ExecBuilder {
                 @Override
                 protected CompletableFuture<Integer> startInternal(
-                    Map<String, String> environment,
+                    CommandSpec command,
-                    Optional<File> directory,
+                        EnvironmentSpec environment,
-                    List<String> commandLine,
+                        PipeSpec redirect) throws IOException {
-                    Optional<RedirectFrom> stdinRedirect,
-                    Optional<RedirectTo> stdoutRedirect,
-                    Optional<RedirectTo> stderrRedirect) throws IOException {
-                    var builder = new ProcessBuilder(commandLine);
+                    var builder = new ProcessBuilder(command.commandLine());
-                    directory.ifPresent(builder::directory);
-                    builder.environment().putAll(environment);
+                    environment.workingDirectory().ifPresent(builder::directory);
-                    // TODO Auto-generated method stub
+                    builder.environment().putAll(environment.environment());
                     var tasks = new ArrayList<CompletableFuture<?>>();
-                    if (!stdoutRedirect.isPresent())
+                    if (!redirect.stdout().isPresent())
                         builder.redirectOutput(Redirect.DISCARD);
-                    if (!stderrRedirect.isPresent())
+                    if (!redirect.stderr().isPresent())
                         builder.redirectError(Redirect.DISCARD);
                     // run process
                     var proc = builder.start();
                     tasks.add(proc.onExit());
-                    stdinRedirect.map(from -> from.redirect(proc.getOutputStream())).ifPresent(tasks::add);
+                    redirect.stdin().map(from -> from.redirect(proc.getOutputStream())).ifPresent(tasks::add);
-                    stdoutRedirect.map(to -> to.redirect(proc.getInputStream())).ifPresent(tasks::add);
+                    redirect.stdout().map(to -> to.redirect(proc.getInputStream())).ifPresent(tasks::add);
-                    stderrRedirect.map(to -> to.redirect(proc.getErrorStream())).ifPresent(tasks::add);
+                    redirect.stderr().map(to -> to.redirect(proc.getErrorStream())).ifPresent(tasks::add);
                     return CompletableFuture
                             .allOf(tasks.toArray(new CompletableFuture<?>[0]))
                             .thenApply(t -> proc.exitValue());
                 }
             }

common/src/main/java/org/implab/gradle/common/tasks/ShellExecTask.java +4 -4

             package org.implab.gradle.common.tasks;
             import java.io.IOException;
             import java.util.Map;
             import java.util.concurrent.ExecutionException;
             import java.util.stream.Stream;
             import org.gradle.api.DefaultTask;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.MapProperty;
             import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.common.dsl.CommandSpec;
             import org.implab.gradle.common.dsl.PipeSpec;
             import org.implab.gradle.common.dsl.RedirectFromSpec;
             import org.implab.gradle.common.dsl.RedirectToSpec;
             import org.implab.gradle.common.dsl.EnvironmentSpec;
             import org.implab.gradle.common.exec.ExecBuilder;
             import org.implab.gradle.common.utils.ObjectsMixin;
             import org.implab.gradle.common.utils.Strings;
             import org.implab.gradle.common.utils.ThrowingConsumer;
             public abstract class ShellExecTask
                     extends DefaultTask
                     implements CommandSpec, PipeSpec, EnvironmentSpec, ObjectsMixin {
                 private final RedirectToSpec redirectStderr = new RedirectToSpec();
                 private final RedirectToSpec redirectStdout = new RedirectToSpec();
                 private final RedirectFromSpec redirectStdin = new RedirectFromSpec();
                 @Internal
                 @Override
                 public abstract DirectoryProperty getWorkingDirectory();
                 @Internal
                 @Override
                 public abstract MapProperty<String, String> getEnvironment();
                 @Internal
                 @Override
                 public abstract ListProperty<String> getCommandLine();
                 /**
                  * STDIN redirection, if not specified, no input will be passed to the command
                  */
                 @Internal
                 @Override
                 public RedirectFromSpec getStdin() {
                     return redirectStdin;
                 }
                 /**
                  * STDOUT redirection, if not specified, redirected to logger::info
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStdout() {
                     return redirectStdout;
                 }
                 /**
                  * STDERR redirection, if not specified, redirected to logger::error
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStderr() {
                     return redirectStderr;
                 }
                 @Override
                 public void commandLine(Object arg0, Object... args) {
                     getCommandLine().set(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 @Override
                 public void args(Object arg0, Object... args) {
                     getCommandLine().addAll(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 protected abstract ExecBuilder execBuilder();
                 @TaskAction
                 public final void run() throws IOException, InterruptedException, ExecutionException {
-                    var execBuilder = execBuilder()
+                    var execBuilder = execBuilder();
-                        .workingDirectory(getWorkingDirectory().get().getAsFile())
+                    execBuilder.workingDirectory(getWorkingDirectory().get().getAsFile());
-                        .environment(getEnvironment().getOrElse(Map.of()))
+                    execBuilder.environment(getEnvironment().getOrElse(Map.of()));
-                        .commandLine(getCommandLine().get());
+                    execBuilder.commandLine(getCommandLine().get());
                     getStdout().getRedirection().ifPresent(execBuilder::stdout);
                     getStderr().getRedirection().ifPresent(execBuilder::stderr);
                     getStdin().getRedirection().ifPresent(execBuilder::stdin);
                     execBuilder.run().thenAccept(ThrowingConsumer.guard(this::checkRetCode)).join();
                 }
                 protected void checkRetCode(Integer code) throws IOException {
                     throw new IOException(String.format("The process is terminated with code %s", code));
                 }
             }

common/src/main/java/org/implab/gradle/common/utils/Values.java +6 -5

             package org.implab.gradle.common.utils;
             import java.util.Iterator;
             import java.util.Map;
-            import java.util.Spliterator;
             import java.util.Spliterators;
             import java.util.Map.Entry;
             import java.util.Optional;
             import java.util.function.Function;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import java.util.stream.StreamSupport;
             import org.gradle.api.provider.Provider;
             public final class Values {
                 private Values() {
                 }
                 /**
                  * Converts values in the specified map
+                 *
                  * @param <K>
                  * @param <V>
                  * @param <U>
                  * @param map
                  * @param mapper
                  * @return
                  */
                 public static <K, V, U> Map<K, U> mapValues(Map<K, V> map, Function<V, U> mapper) {
                     Function<Entry<K, V>, V> getter = Entry::getValue;
                     return map.entrySet().stream()
                             .collect(Collectors.toMap(Entry::getKey, getter.andThen(mapper)));
                 }
-                /** Converts the supplied value to a string.
+                /**
+                 * Converts the supplied value to a string.
                  */
                 public static String toString(Object value) {
                     if (value == null) {
                         return null;
                     } else if (value instanceof String string) {
                         return string;
                     } else if (value instanceof Provider<?> provider) {
                         return toString(provider.getOrNull());
                     } else if (value instanceof Supplier<?> supplier) {
                         return toString(supplier.get());
                     } else {
                         return value.toString();
                     }
                 }
                 public static <T> Stream<T> stream(Iterator<T> remaining) {
-                    var spliterator = Spliterators.spliteratorUnknownSize(remaining, 0);
+                    return StreamSupport.stream(
+                            Spliterators.spliteratorUnknownSize(remaining, 0),
-                    return StreamSupport.stream(spliterator, false);
+                            false);
                 }
                 public static <T> Optional<T> take(Iterator<T> iterator) {
                     return iterator.hasNext() ? Optional.of(iterator.next()) : Optional.empty();
                 }
                 public static <T> Iterable<T> iterable(T[] values) {
                     return () -> new ArrayIterator<>(values);
                 }
                 private static class ArrayIterator<T> implements Iterator<T> {
                     private final T[] data;
                     private int pos = 0;
                     ArrayIterator(T[] data) {
                         this.data = data;
                     }
                     @Override
                     public boolean hasNext() {
                         return pos < data.length;
                     }
                     @Override
                     public T next() {
                         return data[pos++];
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages