// The key to index adhoc event listeners

private static class Key {

private enum IdType {

STRING, ENUM, CLASS

}

private static final Class[] EMPTY_ARG_LIST = new Class[0];

// the event identifier, could be

// 1. a specific string value

// 2. a specific enum value

// 3. an Enum class

// 4. a class extends EventObject

private Object id;

private IdType idType;

private Class[] argTypes;

private boolean varargs;

private Object[] args;

Key(Object id, SimpleEventListener eventListener) {

setId(id);

setArgTypes(eventListener);

}

Key(Object id, List<Class> argTypeList, Object[] args) {

this(id, argTypeList, args, false);

}

Key(Object id, List<Class> argTypeList, Object[] args, boolean varargs) {

setId(id);

this.argTypes = convert(argTypeList);

this.args = args;

this.varargs = varargs;

}

private void setArgTypes(SimpleEventListener eventListener) {

List<Class> argTypeList = eventListener.argumentTypes();

if (null == argTypeList || argTypeList.isEmpty()) {

this.argTypes = EMPTY_ARG_LIST;

return;

}

Class<?> arg0Type = argTypeList.get(0);

this.argTypes = convert(argTypeList);

int varargsIdx = 1;

if (this.id != arg0Type && !arg0Type.isInstance(id)) {

E.illegalArgumentIf(idType == IdType.CLASS, "The first argument in the event listener argument list must be event when binding to an event class (Enum or EventObject). \n\t listener: %s \n\t event: %s", eventListener, this.id);

varargsIdx = 0;

}

this.varargs = (varargsIdx + 1) == argTypeList.size() && Object[].class == argTypeList.get(varargsIdx);

}

private void setId(Object id) {

this.idType = typeOf(id);

this.id = IdType.CLASS == this.idType && !(id instanceof Class) ? id.getClass() : id;

}

static IdType typeOf(Object id) {

if (id instanceof String) {

return IdType.STRING;

} else if (Enum.class.isInstance(id)) {

return IdType.ENUM;

} else {

Class<?> type = id instanceof Class ? (Class<?>) id : id.getClass();

if (Enum.class.isAssignableFrom(type) || EventObject.class.isAssignableFrom(type)) {

return IdType.CLASS;

} else {

throw E.unexpected("Invalid event type: %s", id);

}

}

}

private static Class[] convert(List<Class> argList) {

int sz = argList.size();

Class[] ca = argList.toArray(new Class[sz]);

for (int i = 0; i < sz; ++i) {

ca[i] = $.wrapperClassOf(ca[i]);

}

return ca;

}

private static Class<?> VARARG_TYPE = Object[].class;

private static ConcurrentMap<Class, Class> typeMap = new ConcurrentHashMap<>();

// checkout https://github.com/actframework/actframework/issues/518

private static Class effectiveTypeOf(Object o) {

return effectiveTypeOf(o.getClass());

}

private static Class effectiveTypeOf(Class<?> type) {

if (null == type || Object.class == type) {

return type;

}

Class mappedType = typeMap.get(type);

if (null == mappedType) {

int modifiers = type.getModifiers();

if (!Modifier.isPublic(modifiers)

|| type.isAnonymousClass()

|| type.isLocalClass()

|| type.isMemberClass()) {

Class[] ca = type.getInterfaces();

if (ca.length > 0) {

for (Class intf: ca) {

if (Modifier.isPublic(intf.getModifiers())) {

mappedType = intf;

}

}

}

if (null == mappedType) {

Class<?> parent = type.getSuperclass();

mappedType = (null == parent || Object.class == parent) ? type : effectiveTypeOf(parent);

}

typeMap.putIfAbsent(type, mappedType);

} else {

typeMap.putIfAbsent(type, type);

mappedType = type;

}

}

return mappedType;

}

// create list of keys from event triggering id and argument list

static List<Key> keysOf(Class<?> idClass, Object id, Object[] args, EventBus eventBus) {

List<Key> keys = new ArrayList<>();

List<Class> argTypes = new ArrayList<>();

List<Class> varArgTypes = new ArrayList<>();

varArgTypes.add(VARARG_TYPE);

for (Object arg: args) {

if (null == arg) {

argTypes = null;

break;

}

argTypes.add(effectiveTypeOf(arg));

}

IdType type = typeOf(id);

if (IdType.STRING == type) {

if (!eventBus.stringsWithAdhocListeners.contains(id)) {

return C.list();

}

if (null != argTypes) {

keys.add(new Key(id, argTypes, args));

}

keys.add(new Key(id, varArgTypes, new Object[]{args}));

} else if (IdType.CLASS == type) {

if (!eventBus.classesWithAdhocListeners.contains(idClass)) {

return C.list();

}

varArgTypes.add(0, idClass);

Object[] varArgs = new Object[2];

varArgs[0] = id;

varArgs[1] = args;

keys.add(new Key(id, varArgTypes, varArgs));

if (null != argTypes) {

Object[] finalArgs = $.concat(new Object[]{id}, args);

argTypes.add(0, idClass);

keys.add(new Key(id, argTypes, finalArgs));

}

} else {

// the enum value

if (eventBus.enumsWithAdhocListeners.contains(id)) {

keys.add(new Key(id, varArgTypes, new Object[]{args}));

if (null != argTypes) {

keys.add(new Key(id, argTypes, args));

}

}

// the enum class

if (eventBus.classesWithAdhocListeners.contains(id.getClass())) {

List<Class> varArgTypesForClass = new ArrayList<>(2);

Object[] varArgs = new Object[2];

varArgs[0] = id;

varArgs[1] = args;

varArgTypesForClass.add(id.getClass());

varArgTypesForClass.add(VARARG_TYPE);

keys.add(new Key(id.getClass(), varArgTypesForClass, varArgs, true));

if (null != argTypes) {

List<Class> argTypesForClass = new ArrayList<>(1 + argTypes.size());

argTypesForClass.add(id.getClass());

argTypesForClass.addAll(argTypes);

keys.add(new Key(id.getClass(), argTypesForClass, $.concat(new Object[]{id}, args), true));

}

}

}

return keys;

}

@Override

public int hashCode() {

return $.hc(id, argTypes);

}

@Override

public boolean equals(Object obj) {

if (obj == this) {

return true;

}

if (obj instanceof Key) {

Key that = $.cast(obj);

return $.eq(that.id, this.id) && $.eq2(that.argTypes, this.argTypes);

}

return false;

}

@Override

public String toString() {

return !varargs ? S.fmt("(%s, %s)", id, $.toString2(argTypes)) :

S.fmt("(%s, ...)", id);

}

}

private abstract static class EventContext<T> {

boolean asyncForAsync = true;

boolean asyncForSync = false;

Class<? extends T> eventType;

List<Key> keys;

List<Key> keysForOnceBus;

T event;

Object[] args;

EventContext(T event, Object[] args) {

this.event = event;

this.args = args;

}

EventContext(boolean asyncForAsync, boolean asyncForSync, T event, Object[] args) {

this(event, args);

this.asyncForAsync = asyncForAsync;

this.asyncForSync = asyncForSync;

}

final Class<? extends T> eventType() {

if (null == eventType) {

eventType = lookupEventType();

}

return eventType;

}

List<Key> keys(EventBus eventBus) {

if (eventBus.once) {

if (null == keysForOnceBus) {

keysForOnceBus = Key.keysOf(eventType(), event, args, eventBus);

}

return keysForOnceBus;

} else {

if (null == keys) {

keys = Key.keysOf(eventType(), event, args, eventBus);

}

return keys;

}

}

boolean hasArgs() {

return 0 < args.length;

}

boolean shouldCallActEventListeners(EventBus eventBus) {

return !hasArgs() && eventBus.eventsWithActListeners.contains(eventType());

}

Class<? extends T> lookupEventType() {

return $.cast(event.getClass());

}

abstract boolean shouldCallAdhocEventListeners(EventBus eventBus);

}

private static class EnumEventContext extends EventContext<Enum> {

EnumEventContext(Enum event, Object[] args) {

super(event, args);

}

EnumEventContext(boolean asyncForAsync, boolean asyncForSync, Enum event, Object[] args) {

super(asyncForAsync, asyncForSync, event, args);

}

@Override

Class<? extends Enum> lookupEventType() {

return event.getDeclaringClass();

}

@Override

boolean shouldCallAdhocEventListeners(EventBus eventBus) {

return eventBus.hasAdhocEventListenerFor(event);

}

}

private static class StringEventContext extends EventContext<String> {

StringEventContext(String event, Object[] args) {

super(event, args);

}

StringEventContext(boolean asyncForAsync, boolean asyncForSync, String event, Object[] args) {

super(asyncForAsync, asyncForSync, event, args);

}

@Override

boolean shouldCallAdhocEventListeners(EventBus eventBus) {

return eventBus.hasAdhocEventListenerFor(event);

}

}

private static class EventObjectContext<T extends EventObject> extends EventContext<T> {

EventObjectContext(T event, Object[] args) {

super(event, args);

}

EventObjectContext(boolean asyncForAsync, boolean asyncForSync, T event, Object[] args) {

super(asyncForAsync, asyncForSync, event, args);

}

@Override

Class<? extends T> lookupEventType() {

return $.cast(ActEvent.typeOf(event));

}

@Override

boolean shouldCallAdhocEventListeners(EventBus eventBus) {

return eventBus.hasAdhocEventListenerFor(event);

}

}

private static class ActEventContext extends EventObjectContext<ActEvent<?>> {

ActEventContext(ActEvent<?> event, Object[] args) {

super(event, args);

}

ActEventContext(boolean asyncForAsync, boolean asyncForSync, ActEvent<?> event, Object[] args) {

super(asyncForAsync, asyncForSync, event, args);

}

@Override

Class<? extends ActEvent<?>> lookupEventType() {

return ActEvent.typeOf(event);

}

}

private static final Logger LOGGER = LogManager.get(EventBus.class);

// is this event bus for one time event listener?

private boolean once;

// index SysEvent by SysEventId.ordinal()

private final SysEvent[] sysEventLookup;

// stores sys event listeners, the listener list indexed by event ID ordinal

private final List[] sysEventListeners;

// stores async sys event listeners, the listener list indexed by event ID ordinal

private final List[] asyncSysEventListeners;

// stores the associations from event type to event listeners

private final ConcurrentMap<Class<? extends EventObject>, List<ActEventListener>> actEventListeners;

// stores the associations from event type to async event listeners

private final ConcurrentMap<Class<? extends EventObject>, List<ActEventListener>> asyncActEventListeners;

// stores the association from Key and ad hoc event listeners

private final ConcurrentMap<Key, List<SimpleEventListener>> adhocEventListeners;

// stores the association from Key and async ad hoc event listeners

private final ConcurrentMap<Key, List<SimpleEventListener>> asyncAdhocEventListeners;

// so we can quickly identify if it needs to go ahead to look for listeners

private final Set<Class<?>> classesWithAdhocListeners = new HashSet<>();

private final Set<Enum> enumsWithAdhocListeners = new HashSet<>();

private final Set<String> stringsWithAdhocListeners = new HashSet<>();

private final Set<Class<? extends EventObject>> eventsWithActListeners = new HashSet<>();

// is this event bus for one time event listeners?

private EventBus onceBus;

private EventBus(App app, boolean once) {

super(app, true);

sysEventLookup = initSysEventLookup(app);

sysEventListeners = initAppListenerArray();

asyncSysEventListeners = initAppListenerArray();

actEventListeners = new ConcurrentHashMap<>();

asyncActEventListeners = new ConcurrentHashMap<>();

adhocEventListeners = new ConcurrentHashMap<>();

asyncAdhocEventListeners = new ConcurrentHashMap<>();

loadDefaultEventListeners();

if (!once) {

onceBus = new EventBus(app, true);

onceBus.once = true;

}

}

@Inject

public EventBus(App app) {

this(app, false);

}

@Override

protected void releaseResources() {

if (null != onceBus) {

onceBus.releaseResources();

}

releaseSysEventListeners(sysEventListeners);

releaseSysEventListeners(asyncSysEventListeners);

releaseActEventListeners(actEventListeners);

releaseActEventListeners(asyncActEventListeners);

releaseAdhocEventListeners(adhocEventListeners);

releaseAdhocEventListeners(asyncAdhocEventListeners);

}

/**

@Override

protected void trace(String msg, Object... args) {

msg = S.fmt(msg, args);

if (once) {

msg = S.builder("[once]").append(msg).toString();

}

super.trace(msg);

}

/**

@SuppressWarnings("unchecked")

public synchronized EventBus bind(final SysEventId sysEventId, final SysEventListener<?> sysEventListener) {

boolean async = isAsync(sysEventListener.getClass());

return _bind(async ? asyncSysEventListeners : sysEventListeners, sysEventId, sysEventListener);

}

/**

public EventBus bind(Class<? extends EventObject> eventType, ActEventListener eventListener) {

boolean async = isAsync(eventListener.getClass()) || isAsync(eventType);

return _bind(async ? asyncActEventListeners : actEventListeners, eventType, eventListener, 0);

}

/**

public EventBus bind(Class<? extends EventObject> eventType, ActEventListener eventListener, int ttl) {

boolean async = isAsync(eventListener.getClass()) || isAsync(eventType);

return _bind(async ? asyncActEventListeners : actEventListeners, eventType, eventListener, ttl);

}

/**

public EventBus bind(Object event, final SimpleEventListener eventListener) {

return _bind(event, eventListener, eventListener.isAsync() || _isAsync(event));

}

/**

public synchronized EventBus bindAsync(SysEventId sysEventId, SysEventListener sysEventListener) {

return _bind(asyncSysEventListeners, sysEventId, sysEventListener);

}

/**

public EventBus bindAsync(Class<? extends EventObject> eventType, ActEventListener eventListener) {

return _bind(asyncActEventListeners, eventType, eventListener, 0);

}

/**

public EventBus bindAsync(Class<? extends EventObject> eventType, ActEventListener eventListener, int ttl) {

return _bind(asyncActEventListeners, eventType, eventListener, ttl);

}

public EventBus bindAsync(Object event, final SimpleEventListener eventListener) {

return _bind(event, eventListener, true);

}

/**

public synchronized EventBus bindSync(SysEventId sysEventId, SysEventListener sysEventListener) {

return _bind(sysEventListeners, sysEventId, sysEventListener);

}

/**

public EventBus bindSync(Class<? extends EventObject> eventType, ActEventListener eventListener) {

return _bind(actEventListeners, eventType, eventListener, 0);

}

/**

public EventBus bindSync(final Class<? extends EventObject> eventType, final ActEventListener eventListener, int ttl) {

return _bind(actEventListeners, eventType, eventListener, ttl);

}

/**

public synchronized EventBus emit(SysEventId eventId) {

if (isDestroyed()) {

return this;

}

if (null != onceBus) {

onceBus.emit(eventId);

}

return _emit(true, false, eventId);

}

/**

public EventBus emit(Enum<?> event, Object... args) {

return _emitWithOnceBus(eventContext(event, args));

}

/**

public EventBus emit(String event, Object... args) {

return _emitWithOnceBus(eventContext(event, args));

}

/**

public EventBus emit(EventObject event, Object... args) {

return _emitWithOnceBus(eventContext(event, args));

}

/**

public EventBus emit(ActEvent event, Object... args) {

return _emitWithOnceBus(eventContext(event, args));

}

/**

public synchronized EventBus emitAsync(SysEventId eventId) {

if (isDestroyed()) {

return this;

}

if (null != onceBus) {

onceBus.emit(eventId);

}

return _emit(true, true, eventId);

}

/**

public EventBus emitAsync(Enum<?> event, Object... args) {

return _emitWithOnceBus(eventContextAsync(event, args));

}

/**

public EventBus emitAsync(String event, Object... args) {

return _emitWithOnceBus(eventContextAsync(event, args));

}

/**

public EventBus emitAsync(EventObject event, Object... args) {

return _emitWithOnceBus(eventContextAsync(event, args));

}

/**

public EventBus emitAsync(ActEvent event, Object... args) {

return _emitWithOnceBus(eventContextAsync(event, args));

}

/**

public synchronized EventBus emitSync(SysEventId eventId) {

if (isDestroyed()) {

return this;

}

if (null != onceBus) {

onceBus.emit(eventId);

}

return _emit(false, false, eventId);

}

/**

public EventBus emitSync(Enum<?> event, Object... args) {

return _emitWithOnceBus(eventContextSync(event, args));

}

/**

public EventBus emitSync(String event, Object... args) {

return _emitWithOnceBus(eventContextSync(event, args));

}

/**

public EventBus emitSync(EventObject event, Object... args) {

return _emitWithOnceBus(eventContextSync(event, args));

}

/**

public EventBus emitSync(ActEvent event, Object... args) {

return _emitWithOnceBus(eventContextSync(event, args));

}

/**

public EventBus trigger(SysEventId eventId) {

return emit(eventId);

}

/**