Merge Flux emissions with duplication? - project-reactor

Question

I'm having a Flux that emits items:
data class Item(
val isEgg: Boolean,
val isBasket: Boolean
)
Consider 2 'baskets' and 4 'eggs' emissions. I would like to merge those emissions into two: each containing one 'basket' and 4 'eggs':
Is someone aware of such transformation? Flux is finite and should not exceed 1K items.
EDIT:
What I achieved so far - I grouped emissions into GroupedFlux. Now I would need to combine GroupedFlux containing Basket1, Basket2 with with second containing 'Eggs' in order to produce two baskets with "duplicated" eggs in each one.
val flux = Flux.just("Egg1", "Egg2", "Basket1", "Egg3", "Egg4", "Basket2")
val block = flux.groupBy {
it.startsWith("Egg")
}
Desired Flux: Flux.just("Basket1(Egg1,Egg2, Egg3, Egg4)","Basket2(Egg1,Egg2, Egg3, Egg4)")

Answer 1

You can achieve this result with flatMap and reduce:
void combine() {
Flux<String> flux =
Flux.just("Egg1", "Egg2", "Basket1", "Egg3", "Egg4", "Basket2");
Flux<String> eggs = flux.filter(str -> str.startsWith("Egg"));
Flux<String> basketNames = flux.filter(str -> str.startsWith("Basket"));
basketNames.flatMap(basketName -> eggs.reduce(
new Basket(basketName),
(basket, egg) -> {
basket.add(egg);
return basket;
})
);
}
class Basket {
private final String name;
private final List<String> eggs;
Basket(final String name) {
this.name = name;
this.eggs = new ArrayList<>();
}
public void add(String egg) {
eggs.add(egg);
}
}

Answer 2

Your question is not very clear. I would say that checkout the merge() and concat() operators. That should help.
Edit:
Based on the additional details provided, the question is now clear.
One possible solution is given below:
#Test
public void testBasket() {
Egg eggA = new Egg("A");
Egg eggB = new Egg("B");
Egg eggC = new Egg("C");
Egg eggD = new Egg("D");
Basket basket1 = new Basket("basket1");
Basket basket2 = new Basket("basket2");
Sorter sorter = new Sorter();
Sorter updatedSorter = Flux .just((Item) basket1, (Item) basket2, (Item) eggA, (Item) eggB, (Item) eggC,
(Item) eggD)
.map(sorter::add)
.blockLast();
updatedSorter.process();
Flux<Basket> fluxBasket = Flux.fromStream(sorter.baskets.stream());
fluxBasket.subscribe(d -> System.out.println("data:" + d));
}
class Sorter {
List<Egg> eggs = new ArrayList<Egg>();
List<Basket> baskets = new ArrayList<Basket>();
public Sorter add(Item item) {
if (item.isBasket)
baskets.add((Basket) item);
else
eggs.add((Egg) item);
return this;
}
public Sorter process() {
System.out.println("---- Processing Eggs ----");
for (Basket basket : baskets) {
basket.addEggs(eggs);
}
System.out.println("---- Processing Done ----");
System.out.println(this.toString());
return this;
}
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("(");
for (Basket basket : baskets) {
sb.append(basket.toString() + ",");
}
sb.deleteCharAt(sb.length() - 1);
sb.append(")");
return sb.toString();
}
}
class Item {
boolean isEgg;
boolean isBasket;
}
class Basket extends Item {
public Basket(String name) {
this.name = name;
isBasket = true;
}
String name;
List<Egg> eggs = new ArrayList<Egg>();
public void addEggs(List<Egg> eggs) {
this.eggs = eggs;
}
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(this.name);
sb.append("(");
for (Egg egg : eggs) {
sb.append(egg.toString() + ",");
}
sb.deleteCharAt(sb.length() - 1);
sb.append(")");
return sb.toString();
}
}
class Egg extends Item {
public Egg(String name) {
this.name = name;
isEgg = true;
}
String name;
public String toString() {
return this.name;
}
}
Output:
---- Processing Eggs ----
---- Processing Done ----
(basket1(A,B,C,D),basket2(A,B,C,D))
data:basket1(A,B,C,D)
data:basket2(A,B,C,D)
Edit2:
Another solution, without a blocking call:
#Test
public void testBasket() {
Egg eggA = new Egg("A");
Egg eggB = new Egg("B");
Egg eggC = new Egg("C");
Egg eggD = new Egg("D");
Basket basket1 = new Basket("basket1");
Basket basket2 = new Basket("basket2");
Sorter sorter = new Sorter();
Mono<Sorter> bucketsMono = Flux .just((Item) basket1, (Item) basket2, (Item) eggA, (Item) eggB, (Item) eggC,
(Item) eggD)
.map(sorter::add)
.reduce((sorter1, sorter2) -> sorter.process());
bucketsMono.subscribe(d -> System.out.println("data:" + d));
}
Output:
(basket1),basket2))
---- Processing Eggs ----
---- Processing Done ----
(basket1(A),basket2(A))
---- Processing Eggs ----
---- Processing Done ----
(basket1(A,B),basket2(A,B))
---- Processing Eggs ----
---- Processing Done ----
(basket1(A,B,C),basket2(A,B,C))
---- Processing Eggs ----
---- Processing Done ----
(basket1(A,B,C,D),basket2(A,B,C,D))
data:(basket1(A,B,C,D),basket2(A,B,C,D))