BehaviorSubject functionality for item subclass - rx-java2

Question

I have a Subject that I use as an event bus. This bus emits multiple items, all of a common type:
static class EventBus {
private final Subject<Event> subject = BehaviorSubject.create();
/**
* #param event Event to publish to the subject
*/
void publish(#NonNull Event event) {
this.subject.onNext(event);
}
/**
* Listen to events of a specific class
*
* #param eventClass class of event to listen for
* #param <T> generic type
* #return Observable
*/
<T extends Event> Observable<T> listenForEvents(#NonNull Class<T> eventClass) {
return this.subject
.serialize()
.filter(eventClass::isInstance)
.cast(eventClass);
}
}
abstract static class Event {
int id;
public Event(int id) {
this.id = id;
}
}
final class EventA extends Event {
EventA(int id) {
super(id);
}
}
final class EventB extends Event {
EventB(int id) {
super(id);
}
}
Things that want to listen for specific events can call listenForEvents and pass in the class they want to listen for.
However I want a BehaviorSubject behavior for each class type. An example will illustrate this:
void main() {
EventBus eventBus = new EventBus();
// publish some A's
eventBus.publish(new EventA(1));
eventBus.publish(new EventA(2));
eventBus.publish(new EventA(3));
// publish a B
eventBus.publish(new EventB(4));
eventBus.listenForEvents(EventA.class)
.subscribe(eventA -> {
// 1. I want to receive EventA(3) but I won't receive
// anything because last value in the BehaviorSubject is an EventB
Log.d("TAG", String.valueOf(eventA.id));
});
eventBus.publish(new EventA(5));
// 2. It's only if I put another EventA into the subject
// after I subscribe that I'll seen anything emitted.
}
I have several possible solutions but none of them seem like good ones =)
1.) multiple BehaviorSubjects, one for each event type; these can be lazy created
2.) track "most recent event of type X" outside observable stream
3.) Convert BehaviorSubject with ReplaySubject and use .debounce(10, TimeUnit.MILLISECONDS) and assume that replayed items will be emitted quickly and new items will not be published quickly
private final Subject<Event> subject = ReplaySubject.create();
<T extends Event> Observable<T> listenForEvents(#NonNull Class<T> eventClass) {
return this.subject
.serialize()
.filter(eventClass::isInstance)
.cast(eventClass)
.debounce(10, TimeUnit.MILLISECONDS);
}
Is there a clean way to do this with existing rx operators?