com.googlecode.totallylazy.Option Java Examples

private static Sequence<TestMethod> collectTestMethods(Class aClass, Sequence<Method> methods) throws IOException {
    final Option<JavaClass> javaClass = getJavaClass(aClass);
    if (javaClass.isEmpty()) {
        return empty();
    }

    Map<String, List<JavaMethod>> sourceMethodsByName = getMethods(javaClass.get()).toMap(sourceMethodName());
    Map<String, List<Method>> reflectionMethodsByName = methods.toMap(reflectionMethodName());

    List<TestMethod> testMethods = new ArrayList<TestMethod>();
    TestMethodExtractor extractor = new TestMethodExtractor();
    for (String name : sourceMethodsByName.keySet()) {
        List<JavaMethod> javaMethods = sourceMethodsByName.get(name);
        List<Method> reflectionMethods = reflectionMethodsByName.get(name);
        testMethods.add(extractor.toTestMethod(aClass, javaMethods.get(0), reflectionMethods.get(0)));
        // TODO: If people overload test methods we will have to use the full name rather than the short name
    }

    Sequence<TestMethod> myTestMethods = sequence(testMethods);
    Sequence<TestMethod> parentTestMethods = collectTestMethods(aClass.getSuperclass(), methods);

    return myTestMethods.join(parentTestMethods);
}
 

public static void main(String... args) throws Exception {
    console = new ResultPrinter(printColors(args));

    ConsoleReader consoleReader = new ConsoleReader(System.in, AnsiConsole.out);
    JavaREPLClient client = clientFor(hostname(args), port(args));
    Sequence<String> initialExpressions = initialExpressionsFromFile().join(initialExpressionsFromArgs(args));
    ExpressionReader expressionReader = expressionReaderFor(consoleReader, client, initialExpressions);

    Option<String> expression = none();
    Option<EvaluationResult> result = none();
    while (expression.isEmpty() || !result.isEmpty()) {
        expression = expressionReader.readExpression();

        if (!expression.isEmpty()) {
            result = client.execute(expression.get());
            if (!result.isEmpty()) {
                for (EvaluationLog log : result.get().logs()) {
                    if (!handleTerminalCommand(log)) {
                        handleTerminalMessage(log);
                    }
                }
            }
        }
    }
}
 

public CompletionResult call(String expression) throws Exception {
    final int lastSeparator = lastIndexOfSeparator(characters(" "), expression) + 1;
    final String packagePart = expression.substring(lastSeparator);

    Option<Pair<Class<?>, String>> completion = completionFor(packagePart);

    if (!completion.isEmpty()) {
        Function1<CompletionCandidate, String> value = CompletionCandidate::value;
        Sequence<CompletionCandidate> candidates = reflectionOf(completion.get().first())
                .declaredMembers()
                .filter(isStatic().and(isPublic()).and(not(isSynthetic())))
                .groupBy(candidateName())
                .map(candidate())
                .filter(where(value, startsWith(completion.get().second())));

        final int beginIndex = packagePart.lastIndexOf('.') + 1;
        return new CompletionResult(expression, lastSeparator + beginIndex, candidates);
    } else {
        return new CompletionResult(expression, 0, Sequences.empty(CompletionCandidate.class));
    }
}
 

private Sequence<Result> modifiedResults(final Object expressionInstance) {
    return sequence(expressionInstance.getClass().getDeclaredFields())
            .reduceLeft(new Reducer<Field, Sequence<Result>>() {
                public Sequence<Result> call(Sequence<Result> results, Field field) throws Exception {
                    Option<Result> result = result(field.getName()).filter(where(Result::value, not(equalTo(field.get(expressionInstance)))));

                    if (result.isEmpty())
                        return results;

                    return results.append(Result.result(field.getName(), field.get(expressionInstance)));

                }

                public Sequence<Result> identity() {
                    return empty(Result.class);
                }
            });
}
 

private Sequence<Result> modifiedResults(final Object expressionInstance) {
    return sequence(expressionInstance.getClass().getDeclaredFields())
            .reduceLeft(new Reducer<Field, Sequence<Result>>() {
                public Sequence<Result> call(Sequence<Result> results, Field field) throws Exception {
                    Option<Result> result = result(field.getName()).filter(where(Result::value, not(equalTo(field.get(expressionInstance)))));

                    if (result.isEmpty())
                        return results;

                    return results.append(Result.result(field.getName(), field.get(expressionInstance)));

                }

                public Sequence<Result> identity() {
                    return empty(Result.class);
                }
            });
}
 

@POST
@Hidden
@Path("create")
@Produces(MediaType.APPLICATION_JSON)
public Map<String, Object> create(@FormParam("expression") Option<String> expression,
                                  @FormParam("snap") Option<String> snap) throws Exception {


    Option<String> initial = snap.isDefined()
            ? some(format(":eval %s", snapUri(snap.get())))
            : expression;

    Option<WebConsoleClientHandler> clientHandler = agent.createClient(initial);

    return clientHandler.map(clientHandlerToModel()).get()
            .insert("welcomeMessage", welcomeMessage());
}
 

public void execute(String expression) {
    Option<String> path = parseStringCommand(expression).second();

    if (!path.isEmpty()) {
        try {
            evaluator.evaluate(Strings.lines(path.map(asFile()).get()).toString("\n"))
                    .leftOption()
                    .forEach(throwException());
            logger.success(format("Loaded source file from %s", path.get()));
        } catch (Exception e) {
            logger.error(format("Could not load source file from %s.\n  %s", path.get(), e.getLocalizedMessage()));
        }
    } else {
        logger.error(format("Path not specified"));
    }
}
 

public static final ConsoleHistory historyFromFile(Predicate<String> ignored, Option<File> file) {
    if (file.isEmpty())
        return emptyHistory(ignored, file);

    try {
        return new ConsoleHistory(Strings.lines(file.get()), ignored, file);
    } catch (Exception e) {
        return emptyHistory(ignored, file);
    }
}
 

public Option<Integer> exitCode() {
    if (process.isEmpty())
        return none();

    try {
        Thread.sleep(100);
        return some(process.get().exitValue());
    } catch (Exception e) {
        return none();
    }
}
 

@Test
public void canPutAndReturnOldValue() throws Exception {
    PersistentMap <Integer, String> pairs = map(4, "Four", 5, "Five", 3, "Three", 2, "Two", 6, "Six");
    Pair<PersistentMap <Integer, String>, Option<String>> result = PersistentMap.methods.put(pairs, 4, "NewFour");
    assertThat(result.first().lookup(4).get(), is("NewFour"));
    assertThat(result.second().get(), is("Four"));
}
 

public synchronized Option<WebConsoleClientHandler> removeClient(String id) {
    Option<WebConsoleClientHandler> clientHandler = clients.lookup(id);

    if (!clientHandler.isEmpty()) {
        clientHandler.get().shutdown();
        clients = clients.delete(clientHandler.get().id());
    }

    return clientHandler;
}
 

private static JavaREPLClient clientFor(Option<String> hostname, Option<Integer> port) throws Exception {
    console.printInfo(welcomeMessage());

    if (hostname.isDefined() && port.isDefined()) {
        return connectToRemoteInstance(hostname.get(), port.get());
    } else {
        return startNewLocalInstance("localhost", port.getOrElse(randomServerPort()));
    }
}
 

public Option<String> readExpression(String line) {
    lines = lines.append(line);
    if (expressionIsTerminated(lines)) {
        Option<String> result = some(lines.toString("\n"));
        lines = Sequences.empty();
        return result;
    } else {
        return none();
    }
}
 

private Option<Group<Integer, CompletionResult>> completeGroup(String expression) {
    return completers.map(complete(expression))
            .unique()
            .groupBy(CompletionResult::position)
            .sortBy(groupKey(Integer.class))
            .reverse()
            .headOption();
}
 

@POST
@Hidden
@Path("readExpression")
@Produces(MediaType.APPLICATION_JSON)
public Response readExpression(@FormParam("id") String id, @FormParam("line") String line) {
    Option<WebConsoleClientHandler> clientHandler = agent.client(id);

    if (!clientHandler.isEmpty()) {
        return clientHandler.get().readExpression(line);
    } else {
        return response(BAD_REQUEST);
    }
}
 

public CompletionResult call(String expression) throws Exception {
    Option<Group<Integer, CompletionResult>> group = completeGroup(expression);

    if (group.isEmpty())
        return new CompletionResult(expression, 0, empty(CompletionCandidate.class));

    return new CompletionResult(expression, group.get().key(), group.get().flatMap(CompletionResult::candidates));
}
 

private ConsoleConfig(Option<File> historyFile, Sequence<String> expressions, ConsoleLogger logger, Sequence<Class<? extends Command>> commands, Sequence<Result> results, Boolean sandboxed) {
    this.historyFile = historyFile;
    this.expressions = expressions;
    this.logger = logger;
    this.commands = commands;
    this.results = results;
    this.sandboxed = sandboxed;
}
 

public static <T> Option<Class<T>> classOption(Type concrete) {
    if (concrete instanceof Class) {
        return some(Unchecked.<Class<T>>cast(concrete));
    }
    if (concrete instanceof ParameterizedType) {
        return some(Types.<T>classOf(((ParameterizedType) concrete).getRawType()));
    }
    return none();
}
 

@Override
public Object put(String key, Object value) {
    try {
        Option<Field> field = field(key);
        if (field.isDefined()) {
            Field actual = field.get();
            actual.set(this, Coercer.coerce(actual.getGenericType(), value));
            return Fields.get(actual, this);
        } else {
            return _otherFields.put(key, value);
        }
    } catch (IllegalAccessException e) {
        throw lazyException(e);
    }
}
 

public Option<String> readExpression() {
    Sequence<String> lines = Sequences.empty();

    do {
        lines = lines.append(lineReader.apply(lines));
    } while (!expressionIsTerminated(lines));

    return lines.contains(null)
            ? none(String.class)
            : some(lines.toString("\n").trim());
}
 

@Test
public void supportsHeadOption() {
    assertThat(map(1, "A").
            cons(pair(2, "B")).
            cons(pair(3, "C")).headOption(),
            is(some(pair(2, "B"))));

    assertThat(
            empty(Integer.class, String.class).headOption(),
            is(Option.<Pair<Integer, String>>none()));
}
 

@Override
public Option<V> lookup(K other) {
    int difference = difference(other);
    if (difference == 0) return Option.option(value);
    if (difference < 0) return left.lookup(other);
    return right.lookup(other);
}
 

@tailrec
public Option<V> get(K[] key) {
    if (Arrays.isEmpty(key)) return value;
    Option<ArrayTrie<K, V>> child = childFor(key);
    if (child.isEmpty()) return none();
    return child.get().get(tail(key));
}
 

@tailrec
public boolean contains(K[] key) {
    if (Arrays.isEmpty(key)) return !value.isEmpty();
    Option<ArrayTrie<K, V>> child = childFor(key);
    if (child.isEmpty()) return false;
    return child.get().contains(tail(key));
}
 

@Test
public void isOptional() throws Exception {
    OptionalParser<String> parser = optional(string("foo"));
    Result<Option<String>> result = parser.parse("foo");
    assertThat(result.value(), is(some("foo")));
    assertThat(result.remainder(), is(emptySegment(Character.class)));
}
 

public TimingOutConsole(Console console, Option<Integer> expressionTimeout, Option<Integer> inactivityTimeout) {
    super(console);
    this.expressionTimeout = expressionTimeout;
    this.inactivityTimeout = inactivityTimeout;

    scheduleInactivityTimeout();
}
 

@Override
public Option<T> headOption() {
    return isEmpty()
            ? Option.<T>none()
            : some(head());
}
 

@Override
public Option<T> lookup(T value) {
    return map.lookup(value);
}
 

private ArrayTrie(Option<V> value, PersistentMap<K, ArrayTrie<K, V>> children) {
    this.value = value;
    this.children = children;
}
 

public static <K, V> ArrayTrie<K, V> trie(Option<V> value, PersistentMap<K, ArrayTrie<K, V>> children) {
    return new ArrayTrie<K, V>(value, children);
}