reactor.core.publisher.GroupedFlux Java Examples

private LogDir logDir(
    Map<String, Disk> diskByLogDir,
    GroupedFlux<String, Tuple3<String, String, PartitionReplica>> byLogDir,
    List<Topic> ts) {
  Disk disk = diskByLogDir.getOrDefault(byLogDir.key(), new Disk(0L, 0L));
  return new LogDir(byLogDir.key(), disk.getFree(), disk.getTotal(), ts);
}
 

/**
 * TODO Count number of words of each length.
 * Use {@link Flux#groupBy(Function)}
 */
@Test
public void countAndNumberOfWords() throws Exception {
    final Flux<GroupedFlux<Integer, String>> wordsByLength = LoremIpsum
            .wordStream()
            .groupBy(String::length);

    //when
    final Flux<Tuple2<Integer, Long>> lenToCount = null; // TODO

    //then
    final Set<Tuple2<Integer, Long>> pairs = lenToCount
            .collect(toSet())
            .block();

    assertThat(pairs)
            .containsOnly(
                    of(1, 1L),
                    of(2, 8L),
                    of(3, 15L),
                    of(4, 24L),
                    of(5, 25L),
                    of(6, 14L),
                    of(7, 10L),
                    of(8, 6L),
                    of(9, 9L),
                    of(11, 3L),
                    of(12, 2L)
            );
}
 

@Override
public Flux<GroupedFlux<Integer, Integer>> parallelGrpAvg() {
	Function<Employee, Integer> ages = (emp) ->{
		System.out.println("flatMap thread: " + Thread.currentThread().getName());
		return emp.getAge();
	};
	
	Flux<GroupedFlux<Integer, Integer>> parallelEmpFlux = Flux.fromIterable(employeeDaoImpl.getEmployees())
        .delaySubscription(Duration.of(500L, ChronoUnit.MILLIS))
        .parallel(8) 
        .runOn (Schedulers.parallel())
        .map(ages)
        .groups();
       return parallelEmpFlux;
}
 

@Override
public Flux<GroupedFlux<String, String>> groupNames() {
	Function<Employee, String> names = (emp) -> emp.getFirstName().toLowerCase();
	Flux<GroupedFlux<String, String>> grpsNames = Flux.fromIterable(employeeDaoImpl.getEmployees())
			.map(names)
			.groupBy(key -> key.charAt(0)+"");
	return grpsNames;
}
 

@Test
public void groupByComplete() throws Exception {
	Flux<GroupedFlux<Integer, Integer>> windows = source.groupBy(i -> i % 2);
	subscribeGroups(windows);
	generateAndComplete(0, 6);
	verifyMainComplete(Arrays.asList(0, 2, 4), Arrays.asList(1, 3, 5));
}
 

@Test
public void groupByMainCancel() throws Exception {
	Flux<GroupedFlux<Integer, Integer>> windows = source.groupBy(i -> i % 2);
	subscribeGroups(windows);
	generateWithCancel(0, 5, 1);
	verifyMainCancel(false, Arrays.asList(0, 2, 4), Arrays.asList(1, 3, 5));
}
 

@Test
public void groupByMainCancelNoNewWindow() throws Exception {
	Flux<GroupedFlux<Integer, Integer>> windows = source.groupBy(i -> i % 2);
	subscribeGroups(windows);
	generateWithCancel(0, 1, 1);
	verifyMainCancelNoNewWindow(0, Arrays.asList(0));
}
 

@Test
public void groupByInnerCancel() throws Exception {
	Flux<GroupedFlux<Integer, Integer>> windows = source.groupBy(i -> i % 2);
	subscribeGroups(windows);
	generateWithCancel(0, 9, 1);
	verifyInnerCancel(0, i -> i < 6, Arrays.asList(0, 2, 4), Arrays.asList(1, 3, 5));
}
 

private Flux<MailboxMessage> keepMessageIfMailboxExists(GroupedFlux<MailboxId, MailboxMessage> groupedFlux) {
    CassandraId cassandraId = (CassandraId) groupedFlux.key();
    return mailboxDAO.retrieveMailbox(cassandraId)
        .flatMapMany(any -> groupedFlux)
        .switchIfEmpty(groupedFlux.map(message -> {
            LOGGER.info("Mailbox {} have been deleted but message {} is still attached to it.",
                cassandraId.serialize(),
                message.getMessageId().serialize());
            return message;
        }).then(Mono.empty()));
}
 

public Flux<BindingSet> evaluateReactorInternal(Group expr, BindingSet bindings)
        throws QueryEvaluationException
{
    Set<String> groupByBindings = expr.getGroupBindingNames();

    Flux<BindingSet> s = evaluateReactorInternal(expr.getArg(), bindings);

    Flux<GroupedFlux<BindingSet, BindingSet>> g = s.groupBy((b) -> bindingSetOps.project(groupByBindings, b, bindings));

    //return g.flatMap((gs) -> Streams.just(gs.key()));
    return g.flatMap((gs) -> aggregate(gs, expr, bindings));
}
 

private Mono<Average> calculateAverage(GroupedFlux<Integer, Sensor> group) {
	return group
			.reduce(new Accumulator(0, 0),
					(a, d) -> new Accumulator(a.getCount() + 1, a.getTotalValue() + d.getTemperature()))
			.map(accumulator -> new Average(group.key(), (accumulator.getTotalValue()) / accumulator.getCount()));
}
 

private Mono<Average> calculateAverage(GroupedFlux<Integer, Sensor> group) {
	return group
			.reduce(new Accumulator(0, 0),
					(a, d) -> new Accumulator(a.getCount() + 1, a.getTotalValue() + d.getTemperature()))
			.map(accumulator -> new Average(group.key(), (accumulator.getTotalValue()) / accumulator.getCount()));
}
 

private void subscribeGroups(Flux<GroupedFlux<Integer, Integer>> groups) {
	subscribe(groups.map(m -> m));
}
 

private Flux<DeletedMessageMailboxContext> addOwnerToMetadata(GroupedFlux<MailboxId, MetadataWithMailboxId> groupedFlux) {
    return retrieveMailboxUser(groupedFlux.key())
        .flatMapMany(owner -> groupedFlux.map(metadata ->
            new DeletedMessageMailboxContext(metadata.getMessageMetaData().getMessageId(), owner, ImmutableList.of(metadata.getMailboxId()))));
}
 

public Flux<GroupedFlux<Integer, Integer>> parallelGrpAvg(); 

public Flux<GroupedFlux<String, String>> groupNames();