Java Code Examples for com.googlecode.totallylazy.Sequence#map()

@Test
public void works() throws Exception {
    String xml = "<stream>Hello &amp; World</stream>";
    Sequence<Context> contexts = contexts(xml).filter(xpath(child(name("stream"))));
    Sequence<Node> stream = contexts.map(DomConverter::convert);
    assertThat(stream.size(), is(1));
    assertThat(Xml.asString(stream.head()), is("<stream>Hello &amp; World</stream>"));
}
 

public static CompletionResult fromJson(String json) {
    Map<String, Object> jsonMap = map(Json.map(json));

    Sequence<Map<String, Object>> candidates = CANDIDATES.map(Sequences::sequence).apply(jsonMap);

    return new CompletionResult(
            EXPRESSION.apply(jsonMap),
            POSITION.map(Integer::valueOf).apply(jsonMap),
            candidates.map(candidate -> new CompletionCandidate(VALUE.apply(candidate), FORMS.map(Sequences::sequence).apply(candidate)))
    );
}
 

public static Sequence<String> contentsSequence(Sequence<Node> nodes) {
    return nodes.map(contents());
}
 

public static Sequence<String> textContents(Sequence<Node> nodes) {
    return nodes.map(textContent());
}
 

private FileSource(final Sequence<Pair<String, File>> sources) {
    closeables = closeableList(InputStream.class);
    this.sources = sources.map(pair ->
            Source.source(pair.first(), () -> new Date(pair.second().lastModified()), () -> inputStream(pair.second()), pair.second().isDirectory()));
}
 

@Test
public void canMapWithAField() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new FieldOn<User, String>() { { get(instance.firstName); } });
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

@Test
public void canMapAMethod() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(method(on(User.class).firstName()));
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

@Test
public void canMapAMethodWithAnArgument() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(method(on(User.class).say("Hello")));
    assertThat(firstNames, hasExactly("Dan says 'Hello'", "Matt says 'Hello'"));
}
 

@Test
public void canUseInstanceInsteadOfCallForReadability() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{instance.firstName();}});
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

@Test
public void canMapAMethod() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{call.firstName();}});
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

@Test
public void canMapAMethodWithAnArgument() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{call.say("Hello");}});
    assertThat(firstNames, hasExactly("Dan says 'Hello'", "Matt says 'Hello'"));
}
 

private Sequence<Command> commandInstances(Sequence<Class<? extends Command>> commands) {
    return commands.map(context::create);
}