Java Code Examples for com.googlecode.totallylazy.Option#isEmpty()

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

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

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

    if (!clientHandler.isEmpty()) {
        String snapId = UUID.randomUUID().toString();

        Files.write(clientHandler.get().history().toString("\n").getBytes(), snapFile(snapId));

        return ok()
                .entity(emptyMap(String.class, Object.class)
                        .insert("snap", snapId)
                        .insert("uri", snapUri(snapId).toString())
                );

    } else {
        return response(BAD_REQUEST);
    }
}
 

@Override
protected A getNext() throws Exception {
    Option<Pair<A, B>> result = callable.call(state);
    if (result.isEmpty()) return finished();
    Pair<A, B> pair = result.get();
    state = pair.second();
    return pair.first();
}
 

private Option<Pair<Class<?>, String>> completionFor(String expression) {
    Option<Pair<String, Sequence<String>>> parsedClass = parseExpression(pair(expression, Sequences.empty(String.class)));

    if (!parsedClass.isEmpty() && !parsedClass.get().second().isEmpty()) {
        return some(Pair.<Class<?>, String>pair(
                evaluator.classFrom(parsedClass.get().first()).get(),
                parsedClass.get().second().toString(".").trim()));
    } else {
        return none();
    }
}
 

public final Option<java.lang.reflect.Type> typeOfExpression(String expression) {
    Either<? extends Throwable, Evaluation> evaluation = tryEvaluate(expression);

    Option<java.lang.reflect.Type> expressionType = none();
    if (evaluation.isRight()) {
        Option<Result> result = evaluation.right().result();
        if (!result.isEmpty()) {
            expressionType = some(result.get().type());
        }
    }

    return expressionType;
}
 

@POST
@Hidden
@Path("remove")
@Produces(MediaType.APPLICATION_JSON)
public Response remove(@FormParam("id") String id) {
    Option<WebConsoleClientHandler> clientHandler = agent.removeClient(id);
    if (!clientHandler.isEmpty()) {
        return response(OK);
    } else {
        return response(BAD_REQUEST);
    }
}
 

@GET
@Hidden
@Path("completions")
@Produces(MediaType.APPLICATION_JSON)
public Response completions(@QueryParam("id") String id, @QueryParam("expression") String expression) {
    Option<WebConsoleClientHandler> clientHandler = agent.client(id);

    if (!clientHandler.isEmpty()) {
        return clientHandler.get().completions(expression);
    } else {
        return response(BAD_REQUEST);
    }
}
 

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

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

    if (!clientHandler.isEmpty()) {
        return clientHandler.get().execute(expression);
    } else {
        return response(BAD_REQUEST);
    }
}
 

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

@SuppressWarnings("unchecked")
public final <T> T valueOf(final String key) {
    Option<Result> result = context.results()
            .find(where(Result::key, equalTo(key)));

    if (result.isEmpty())
        throw new IllegalArgumentException("Result '" + key + "' not found");

    return (T) result.get().value();
}
 

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

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 final Option<java.lang.reflect.Type> typeOfExpression(String expression) {
    Either<? extends Throwable, Evaluation> evaluation = tryEvaluate(expression);

    Option<java.lang.reflect.Type> expressionType = none();
    if (evaluation.isRight()) {
        Option<Result> result = evaluation.right().result();
        if (!result.isEmpty()) {
            expressionType = some(result.get().type());
        }
    }

    return expressionType;
}
 

public void execute(String expression) {
    Integer historyItem = parseNumericCommand(expression).second().getOrElse(history.items().size());
    Option<String> fromHistory = history.items().drop(historyItem - 1).headOption();

    if (!fromHistory.isEmpty()) {
        console.execute(fromHistory.get());
    } else {
        logger.error("Expression not found.\n");
    }
}
 

public static Element expectElement(final Node node, String xpath) {
    Option<Element> element = selectElement(node, xpath);
    if (element.isEmpty())
        throw new NoSuchElementException("No element for xpath " + xpath);
    return element.get();
}
 

public static Node expectNode(final Node node, String xpath) {
    Option<Node> foundNode = selectNode(node, xpath);
    if (foundNode.isEmpty())
        throw new NoSuchElementException("No node for xpath " + xpath);
    return foundNode.get();
}
 

public boolean contains(Segment<K> key){
    if(key.isEmpty()) return !value.isEmpty();
    Option<Trie<K, V>> child = childFor(key);
    return !child.isEmpty() && child.get().contains(key.tail());
}